/*
 * uCharts (R)
 * 高性能跨平台图表库，支持H5、APP、小程序（微信/支付宝/百度/头条/QQ/360/快手）、Vue、Taro等支持canvas的框架平台
 * Copyright (C) 2018-2022 QIUN (R) 秋云 https://www.ucharts.cn All rights reserved.
 * Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
 * 复制使用请保留本段注释，感谢支持开源！
 *
 * uCharts (R) 官方网站
 * https://www.uCharts.cn
 *
 * 开源地址:
 * https://gitee.com/uCharts/uCharts
 *
 * uni-app插件市场地址：
 * http://ext.dcloud.net.cn/plugin?id=271
 *
 */

'use strict'

var config = {
  version: 'v2.5.0-20230101',
  yAxisWidth: 15,
  xAxisHeight: 22,
  padding: [10, 10, 10, 10],
  rotate: false,
  fontSize: 13,
  fontColor: '#666666',
  dataPointShape: ['circle', 'circle', 'circle', 'circle'],
  color: [
    '#1890FF',
    '#91CB74',
    '#FAC858',
    '#EE6666',
    '#73C0DE',
    '#3CA272',
    '#FC8452',
    '#9A60B4',
    '#ea7ccc'
  ],
  linearColor: [
    '#0EE2F8',
    '#2BDCA8',
    '#FA7D8D',
    '#EB88E2',
    '#2AE3A0',
    '#0EE2F8',
    '#EB88E2',
    '#6773E3',
    '#F78A85'
  ],
  pieChartLinePadding: 15,
  pieChartTextPadding: 5,
  titleFontSize: 20,
  subtitleFontSize: 15,
  radarLabelTextMargin: 13
}

var assign = function (target, ...varArgs) {
  if (target == null) {
    throw new TypeError('[uCharts] Cannot convert undefined or null to object')
  }
  if (!varArgs || varArgs.length <= 0) {
    return target
  }
  // 深度合并对象
  function deepAssign(obj1, obj2) {
    for (let key in obj2) {
      obj1[key] =
        obj1[key] && obj1[key].toString() === '[object Object]'
          ? deepAssign(obj1[key], obj2[key])
          : (obj1[key] = obj2[key])
    }
    return obj1
  }
  varArgs.forEach((val) => {
    target = deepAssign(target, val)
  })
  return target
}

var util = {
  toFixed: function toFixed(num, limit) {
    limit = limit || 2
    if (this.isFloat(num)) {
      num = num.toFixed(limit)
    }
    return num
  },
  isFloat: function isFloat(num) {
    return num % 1 !== 0
  },
  approximatelyEqual: function approximatelyEqual(num1, num2) {
    return Math.abs(num1 - num2) < 1e-10
  },
  isSameSign: function isSameSign(num1, num2) {
    return (
      (Math.abs(num1) === num1 && Math.abs(num2) === num2) ||
      (Math.abs(num1) !== num1 && Math.abs(num2) !== num2)
    )
  },
  isSameXCoordinateArea: function isSameXCoordinateArea(p1, p2) {
    return this.isSameSign(p1.x, p2.x)
  },
  isCollision: function isCollision(obj1, obj2) {
    obj1.end = {}
    obj1.end.x = obj1.start.x + obj1.width
    obj1.end.y = obj1.start.y - obj1.height
    obj2.end = {}
    obj2.end.x = obj2.start.x + obj2.width
    obj2.end.y = obj2.start.y - obj2.height
    var flag =
      obj2.start.x > obj1.end.x ||
      obj2.end.x < obj1.start.x ||
      obj2.end.y > obj1.start.y ||
      obj2.start.y < obj1.end.y
    return !flag
  }
}

//兼容H5点击事件
function getH5Offset(e) {
  e.mp = {
    changedTouches: []
  }
  e.mp.changedTouches.push({
    x: e.offsetX,
    y: e.offsetY
  })
  return e
}

// hex 转 rgba
function hexToRgb(hexValue, opc) {
  var rgx = /^#?([a-f\d])([a-f\d])([a-f\d])$/i
  var hex = hexValue.replace(rgx, function (m, r, g, b) {
    return r + r + g + g + b + b
  })
  var rgb = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
  var r = parseInt(rgb[1], 16)
  var g = parseInt(rgb[2], 16)
  var b = parseInt(rgb[3], 16)
  return 'rgba(' + r + ',' + g + ',' + b + ',' + opc + ')'
}

function findRange(num, type, limit) {
  if (isNaN(num)) {
    throw new Error('[uCharts] series数据需为Number格式')
  }
  limit = limit || 10
  type = type ? type : 'upper'
  var multiple = 1
  while (limit < 1) {
    limit *= 10
    multiple *= 10
  }
  if (type === 'upper') {
    num = Math.ceil(num * multiple)
  } else {
    num = Math.floor(num * multiple)
  }
  while (num % limit !== 0) {
    if (type === 'upper') {
      if (num == num + 1) {
        //修复数据值过大num++无效的bug by 向日葵 @xrk_jy
        break
      }
      num++
    } else {
      num--
    }
  }
  return num / multiple
}

function calCandleMA(dayArr, nameArr, colorArr, kdata) {
  let seriesTemp = []
  for (let k = 0; k < dayArr.length; k++) {
    let seriesItem = {
      data: [],
      name: nameArr[k],
      color: colorArr[k]
    }
    for (let i = 0, len = kdata.length; i < len; i++) {
      if (i < dayArr[k]) {
        seriesItem.data.push(null)
        continue
      }
      let sum = 0
      for (let j = 0; j < dayArr[k]; j++) {
        sum += kdata[i - j][1]
      }
      seriesItem.data.push(+(sum / dayArr[k]).toFixed(3))
    }
    seriesTemp.push(seriesItem)
  }
  return seriesTemp
}

function calValidDistance(self, distance, chartData, config, opts) {
  var dataChartAreaWidth = opts.width - opts.area[1] - opts.area[3]
  var dataChartWidth = chartData.eachSpacing * (opts.chartData.xAxisData.xAxisPoints.length - 1)
  if (
    opts.type == 'mount' &&
    opts.extra &&
    opts.extra.mount &&
    opts.extra.mount.widthRatio &&
    opts.extra.mount.widthRatio > 1
  ) {
    if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
    dataChartWidth += (opts.extra.mount.widthRatio - 1) * chartData.eachSpacing
  }
  var validDistance = distance
  if (distance >= 0) {
    validDistance = 0
    self.uevent.trigger('scrollLeft')
    self.scrollOption.position = 'left'
    opts.xAxis.scrollPosition = 'left'
  } else if (Math.abs(distance) >= dataChartWidth - dataChartAreaWidth) {
    validDistance = dataChartAreaWidth - dataChartWidth
    self.uevent.trigger('scrollRight')
    self.scrollOption.position = 'right'
    opts.xAxis.scrollPosition = 'right'
  } else {
    self.scrollOption.position = distance
    opts.xAxis.scrollPosition = distance
  }
  return validDistance
}

function isInAngleRange(angle, startAngle, endAngle) {
  function adjust(angle) {
    while (angle < 0) {
      angle += 2 * Math.PI
    }
    while (angle > 2 * Math.PI) {
      angle -= 2 * Math.PI
    }
    return angle
  }
  angle = adjust(angle)
  startAngle = adjust(startAngle)
  endAngle = adjust(endAngle)
  if (startAngle > endAngle) {
    endAngle += 2 * Math.PI
    if (angle < startAngle) {
      angle += 2 * Math.PI
    }
  }
  return angle >= startAngle && angle <= endAngle
}

function createCurveControlPoints(points, i) {
  function isNotMiddlePoint(points, i) {
    if (points[i - 1] && points[i + 1]) {
      return (
        points[i].y >= Math.max(points[i - 1].y, points[i + 1].y) ||
        points[i].y <= Math.min(points[i - 1].y, points[i + 1].y)
      )
    } else {
      return false
    }
  }
  function isNotMiddlePointX(points, i) {
    if (points[i - 1] && points[i + 1]) {
      return (
        points[i].x >= Math.max(points[i - 1].x, points[i + 1].x) ||
        points[i].x <= Math.min(points[i - 1].x, points[i + 1].x)
      )
    } else {
      return false
    }
  }
  var a = 0.2
  var b = 0.2
  var pAx = null
  var pAy = null
  var pBx = null
  var pBy = null
  if (i < 1) {
    pAx = points[0].x + (points[1].x - points[0].x) * a
    pAy = points[0].y + (points[1].y - points[0].y) * a
  } else {
    pAx = points[i].x + (points[i + 1].x - points[i - 1].x) * a
    pAy = points[i].y + (points[i + 1].y - points[i - 1].y) * a
  }

  if (i > points.length - 3) {
    var last = points.length - 1
    pBx = points[last].x - (points[last].x - points[last - 1].x) * b
    pBy = points[last].y - (points[last].y - points[last - 1].y) * b
  } else {
    pBx = points[i + 1].x - (points[i + 2].x - points[i].x) * b
    pBy = points[i + 1].y - (points[i + 2].y - points[i].y) * b
  }
  if (isNotMiddlePoint(points, i + 1)) {
    pBy = points[i + 1].y
  }
  if (isNotMiddlePoint(points, i)) {
    pAy = points[i].y
  }
  if (isNotMiddlePointX(points, i + 1)) {
    pBx = points[i + 1].x
  }
  if (isNotMiddlePointX(points, i)) {
    pAx = points[i].x
  }
  if (
    pAy >= Math.max(points[i].y, points[i + 1].y) ||
    pAy <= Math.min(points[i].y, points[i + 1].y)
  ) {
    pAy = points[i].y
  }
  if (
    pBy >= Math.max(points[i].y, points[i + 1].y) ||
    pBy <= Math.min(points[i].y, points[i + 1].y)
  ) {
    pBy = points[i + 1].y
  }
  if (
    pAx >= Math.max(points[i].x, points[i + 1].x) ||
    pAx <= Math.min(points[i].x, points[i + 1].x)
  ) {
    pAx = points[i].x
  }
  if (
    pBx >= Math.max(points[i].x, points[i + 1].x) ||
    pBx <= Math.min(points[i].x, points[i + 1].x)
  ) {
    pBx = points[i + 1].x
  }
  return {
    ctrA: {
      x: pAx,
      y: pAy
    },
    ctrB: {
      x: pBx,
      y: pBy
    }
  }
}

function convertCoordinateOrigin(x, y, center) {
  return {
    x: center.x + x,
    y: center.y - y
  }
}

function avoidCollision(obj, target) {
  if (target) {
    // is collision test
    while (util.isCollision(obj, target)) {
      if (obj.start.x > 0) {
        obj.start.y--
      } else if (obj.start.x < 0) {
        obj.start.y++
      } else {
        if (obj.start.y > 0) {
          obj.start.y++
        } else {
          obj.start.y--
        }
      }
    }
  }
  return obj
}

function fixPieSeries(series, opts, config) {
  let pieSeriesArr = []
  if (series.length > 0 && series[0].data.constructor.toString().indexOf('Array') > -1) {
    opts._pieSeries_ = series
    let oldseries = series[0].data
    for (var i = 0; i < oldseries.length; i++) {
      oldseries[i].formatter = series[0].formatter
      oldseries[i].data = oldseries[i].value
      pieSeriesArr.push(oldseries[i])
    }
    opts.series = pieSeriesArr
  } else {
    pieSeriesArr = series
  }
  return pieSeriesArr
}

function fillSeries(series, opts, config) {
  var index = 0
  for (var i = 0; i < series.length; i++) {
    let item = series[i]
    if (!item.color) {
      item.color = config.color[index]
      index = (index + 1) % config.color.length
    }
    if (!item.linearIndex) {
      item.linearIndex = i
    }
    if (!item.index) {
      item.index = 0
    }
    if (!item.type) {
      item.type = opts.type
    }
    if (typeof item.show == 'undefined') {
      item.show = true
    }
    if (!item.type) {
      item.type = opts.type
    }
    if (!item.pointShape) {
      item.pointShape = 'circle'
    }
    if (!item.legendShape) {
      switch (item.type) {
        case 'line':
          item.legendShape = 'line'
          break
        case 'column':
        case 'bar':
          item.legendShape = 'rect'
          break
        case 'area':
        case 'mount':
          item.legendShape = 'triangle'
          break
        default:
          item.legendShape = 'circle'
      }
    }
  }
  return series
}

function fillCustomColor(linearType, customColor, series, config) {
  var newcolor = customColor || []
  if (linearType == 'custom' && newcolor.length == 0) {
    newcolor = config.linearColor
  }
  if (linearType == 'custom' && newcolor.length < series.length) {
    let chazhi = series.length - newcolor.length
    for (var i = 0; i < chazhi; i++) {
      newcolor.push(config.linearColor[(i + 1) % config.linearColor.length])
    }
  }
  return newcolor
}

function getDataRange(minData, maxData) {
  var limit = 0
  var range = maxData - minData
  if (range >= 10000) {
    limit = 1000
  } else if (range >= 1000) {
    limit = 100
  } else if (range >= 100) {
    limit = 10
  } else if (range >= 10) {
    limit = 5
  } else if (range >= 1) {
    limit = 1
  } else if (range >= 0.1) {
    limit = 0.1
  } else if (range >= 0.01) {
    limit = 0.01
  } else if (range >= 0.001) {
    limit = 0.001
  } else if (range >= 0.0001) {
    limit = 0.0001
  } else if (range >= 0.00001) {
    limit = 0.00001
  } else {
    limit = 0.000001
  }
  return {
    minRange: findRange(minData, 'lower', limit),
    maxRange: findRange(maxData, 'upper', limit)
  }
}

function measureText(text, fontSize, context) {
  var width = 0
  text = String(text)
  // #ifdef MP-ALIPAY || MP-BAIDU || APP-NVUE
  context = false
  // #endif
  if (context !== false && context !== undefined && context.setFontSize && context.measureText) {
    context.setFontSize(fontSize)
    return context.measureText(text).width
  } else {
    var text = text.split('')
    for (let i = 0; i < text.length; i++) {
      let item = text[i]
      if (/[a-zA-Z]/.test(item)) {
        width += 7
      } else if (/[0-9]/.test(item)) {
        width += 5.5
      } else if (/\./.test(item)) {
        width += 2.7
      } else if (/-/.test(item)) {
        width += 3.25
      } else if (/:/.test(item)) {
        width += 2.5
      } else if (/[\u4e00-\u9fa5]/.test(item)) {
        width += 10
      } else if (/\(|\)/.test(item)) {
        width += 3.73
      } else if (/\s/.test(item)) {
        width += 2.5
      } else if (/%/.test(item)) {
        width += 8
      } else {
        width += 10
      }
    }
    return (width * fontSize) / 10
  }
}

function dataCombine(series) {
  return series.reduce(function (a, b) {
    return (a.data ? a.data : a).concat(b.data)
  }, [])
}

function dataCombineStack(series, len) {
  var sum = new Array(len)
  for (var j = 0; j < sum.length; j++) {
    sum[j] = 0
  }
  for (var i = 0; i < series.length; i++) {
    for (var j = 0; j < sum.length; j++) {
      sum[j] += series[i].data[j]
    }
  }
  return series.reduce(function (a, b) {
    return (a.data ? a.data : a).concat(b.data).concat(sum)
  }, [])
}

function getTouches(touches, opts, e) {
  let x, y
  if (touches.clientX) {
    if (opts.rotate) {
      y = opts.height - touches.clientX * opts.pix
      x =
        (touches.pageY -
          e.currentTarget.offsetTop -
          (opts.height / opts.pix / 2) * (opts.pix - 1)) *
        opts.pix
    } else {
      x = touches.clientX * opts.pix
      y =
        (touches.pageY -
          e.currentTarget.offsetTop -
          (opts.height / opts.pix / 2) * (opts.pix - 1)) *
        opts.pix
    }
  } else {
    if (opts.rotate) {
      y = opts.height - touches.x * opts.pix
      x = touches.y * opts.pix
    } else {
      x = touches.x * opts.pix
      y = touches.y * opts.pix
    }
  }
  return {
    x: x,
    y: y
  }
}

function getSeriesDataItem(series, index, group) {
  var data = []
  var newSeries = []
  var indexIsArr = index.constructor.toString().indexOf('Array') > -1
  if (indexIsArr) {
    let tempSeries = filterSeries(series)
    for (var i = 0; i < group.length; i++) {
      newSeries.push(tempSeries[group[i]])
    }
  } else {
    newSeries = series
  }
  for (let i = 0; i < newSeries.length; i++) {
    let item = newSeries[i]
    // 在 tooltip 中忽略 area-range 类型的数据
    if (item && item.type === 'area-range') {
      continue
    }
    let tmpindex = -1
    if (indexIsArr) {
      tmpindex = index[i]
    } else {
      tmpindex = index
    }
    if (item.data[tmpindex] !== null && typeof item.data[tmpindex] !== 'undefined' && item.show) {
      let seriesItem = {}
      seriesItem.color = item.color
      seriesItem.type = item.type
      seriesItem.style = item.style
      seriesItem.pointShape = item.pointShape
      seriesItem.disableLegend = item.disableLegend
      seriesItem.legendShape = item.legendShape
      seriesItem.name = item.name
      seriesItem.show = item.show
      seriesItem.data = item.formatter ? item.formatter(item.data[tmpindex]) : item.data[tmpindex]
      data.push(seriesItem)
    }
  }
  return data
}

function getMaxTextListLength(list, fontSize, context) {
  var lengthList = list.map(function (item) {
    return measureText(item, fontSize, context)
  })
  return Math.max.apply(null, lengthList)
}

function getRadarCoordinateSeries(length) {
  var eachAngle = (2 * Math.PI) / length
  var CoordinateSeries = []
  for (var i = 0; i < length; i++) {
    CoordinateSeries.push(eachAngle * i)
  }
  return CoordinateSeries.map(function (item) {
    return -1 * item + Math.PI / 2
  })
}

function getToolTipData(seriesData, opts, index, group, categories) {
  var option = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}
  var calPoints = opts.chartData.calPoints ? opts.chartData.calPoints : []
  let points = {}
  if (group.length > 0) {
    let filterPoints = []
    for (let i = 0; i < group.length; i++) {
      if (calPoints[group[i]] && (Array.isArray(index) ? calPoints[group[i]][index[i]] : true)) {
        filterPoints.push(calPoints[group[i]])
      }
    }
    if (filterPoints.length > 0 && typeof index !== 'undefined') {
      points = filterPoints[0][Array.isArray(index) ? index[0] : index]
    }
  } else {
    for (let i = 0; i < calPoints.length; i++) {
      if (calPoints[i] && calPoints[i][index]) {
        points = calPoints[i][index]
        break
      }
    }
  }
  // 兜底：若未能从 calPoints 拿到有效坐标，则回退到基于 x 轴刻度的估算值，避免 tooltip 偶发不显示
  if (!points || typeof points.x === 'undefined' || typeof points.y === 'undefined') {
    try {
      const xAxisPoints =
        opts.chartData && opts.chartData.xAxisPoints ? opts.chartData.xAxisPoints : []
      const eachSpacing =
        opts.chartData && typeof opts.chartData.eachSpacing !== 'undefined'
          ? opts.chartData.eachSpacing
          : 0
      const idx = Array.isArray(index) ? index[0] : index
      if (xAxisPoints.length && typeof idx === 'number') {
        points = { x: xAxisPoints[idx] + eachSpacing / 2, y: 0 }
      }
    } catch (e) {
      points = { x: 0, y: 0 }
    }
  }
  var textList = seriesData.map(function (item) {
    let titleText = null
    if (opts.categories && opts.categories.length > 0) {
      titleText = categories[index]
    }
    return {
      text: option.formatter
        ? option.formatter(item, titleText, index, opts)
        : item.name + ': ' + item.data,
      color: item.color,
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
  })
  var offset = {
    x: Math.round(points.x),
    y: Math.round(points.y)
  }
  return {
    textList: textList,
    offset: offset
  }
}

function getMixToolTipData(seriesData, opts, index, categories) {
  var option = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}
  var points = opts.chartData.xAxisPoints[index] + opts.chartData.eachSpacing / 2
  var textList = seriesData.map(function (item) {
    return {
      text: option.formatter
        ? option.formatter(item, categories[index], index, opts)
        : item.name + ': ' + item.data,
      color: item.color,
      disableLegend: item.disableLegend ? true : false,
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
  })
  textList = textList.filter(function (item) {
    if (item.disableLegend !== true) {
      return item
    }
  })
  var offset = {
    x: Math.round(points),
    y: 0
  }
  return {
    textList: textList,
    offset: offset
  }
}

function getCandleToolTipData(series, seriesData, opts, index, categories, extra) {
  var option = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {}
  var calPoints = opts.chartData.calPoints
  let upColor = extra.color.upFill
  let downColor = extra.color.downFill
  //颜色顺序为开盘，收盘，最低，最高
  let color = [upColor, upColor, downColor, upColor]
  var textList = []
  seriesData.map(function (item) {
    if (index == 0) {
      if (item.data[1] - item.data[0] < 0) {
        color[1] = downColor
      } else {
        color[1] = upColor
      }
    } else {
      if (item.data[0] < series[index - 1][1]) {
        color[0] = downColor
      }
      if (item.data[1] < item.data[0]) {
        color[1] = downColor
      }
      if (item.data[2] > series[index - 1][1]) {
        color[2] = upColor
      }
      if (item.data[3] < series[index - 1][1]) {
        color[3] = downColor
      }
    }
    let text1 = {
      text: '开盘：' + item.data[0],
      color: color[0],
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
    let text2 = {
      text: '收盘：' + item.data[1],
      color: color[1],
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
    let text3 = {
      text: '最低：' + item.data[2],
      color: color[2],
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
    let text4 = {
      text: '最高：' + item.data[3],
      color: color[3],
      legendShape:
        opts.extra.tooltip.legendShape == 'auto' ? item.legendShape : opts.extra.tooltip.legendShape
    }
    textList.push(text1, text2, text3, text4)
  })
  var validCalPoints = []
  var offset = {
    x: 0,
    y: 0
  }
  for (let i = 0; i < calPoints.length; i++) {
    let points = calPoints[i]
    if (typeof points[index] !== 'undefined' && points[index] !== null) {
      validCalPoints.push(points[index])
    }
  }
  offset.x = Math.round(validCalPoints[0][0].x)
  return {
    textList: textList,
    offset: offset
  }
}

function filterSeries(series) {
  let tempSeries = []
  for (let i = 0; i < series.length; i++) {
    if (series[i].show == true) {
      tempSeries.push(series[i])
    }
  }
  return tempSeries
}

function findCurrentIndex(currentPoints, calPoints, opts, config) {
  var offset = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0
  var current = { index: -1, group: [] }
  var spacing = opts.chartData.eachSpacing / 2
  let xAxisPoints = []
  if (calPoints && calPoints.length > 0) {
    if (!opts.categories) {
      spacing = 0
    } else {
      for (let i = 1; i < opts.chartData.xAxisPoints.length; i++) {
        xAxisPoints.push(opts.chartData.xAxisPoints[i] - spacing)
      }
      if ((opts.type == 'line' || opts.type == 'area') && opts.xAxis.boundaryGap == 'justify') {
        xAxisPoints = opts.chartData.xAxisPoints
      }
    }
    if (isInExactChartArea(currentPoints, opts, config)) {
      if (!opts.categories) {
        let timePoints = Array(calPoints.length)
        for (let i = 0; i < calPoints.length; i++) {
          timePoints[i] = Array(calPoints[i].length)
          for (let j = 0; j < calPoints[i].length; j++) {
            timePoints[i][j] = Math.abs(calPoints[i][j].x - currentPoints.x)
          }
        }
        let pointValue = Array(timePoints.length)
        let pointIndex = Array(timePoints.length)
        for (let i = 0; i < timePoints.length; i++) {
          pointValue[i] = Math.min.apply(null, timePoints[i])
          pointIndex[i] = timePoints[i].indexOf(pointValue[i])
        }
        let minValue = Math.min.apply(null, pointValue)
        current.index = []
        for (let i = 0; i < pointValue.length; i++) {
          if (pointValue[i] == minValue) {
            current.group.push(i)
            current.index.push(pointIndex[i])
          }
        }
      } else {
        xAxisPoints.forEach(function (item, index) {
          if (currentPoints.x + offset + spacing > item) {
            current.index = index
          }
        })
      }
    }
  }
  return current
}

function findBarChartCurrentIndex(currentPoints, calPoints, opts, config) {
  var offset = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0
  var current = { index: -1, group: [] }
  var spacing = opts.chartData.eachSpacing / 2
  let yAxisPoints = opts.chartData.yAxisPoints
  if (calPoints && calPoints.length > 0) {
    if (isInExactChartArea(currentPoints, opts, config)) {
      yAxisPoints.forEach(function (item, index) {
        if (currentPoints.y + offset + spacing > item) {
          current.index = index
        }
      })
    }
  }
  return current
}

function findLegendIndex(currentPoints, legendData, opts) {
  let currentIndex = -1
  let gap = 0
  if (isInExactLegendArea(currentPoints, legendData.area)) {
    let points = legendData.points
    let index = -1
    for (let i = 0, len = points.length; i < len; i++) {
      let item = points[i]
      for (let j = 0; j < item.length; j++) {
        index += 1
        let area = item[j]['area']
        if (
          area &&
          currentPoints.x > area[0] - gap &&
          currentPoints.x < area[2] + gap &&
          currentPoints.y > area[1] - gap &&
          currentPoints.y < area[3] + gap
        ) {
          currentIndex = index
          break
        }
      }
    }
    return currentIndex
  }
  return currentIndex
}

function isInExactLegendArea(currentPoints, area) {
  return (
    currentPoints.x > area.start.x &&
    currentPoints.x < area.end.x &&
    currentPoints.y > area.start.y &&
    currentPoints.y < area.end.y
  )
}

function isInExactChartArea(currentPoints, opts, config) {
  return (
    currentPoints.x <= opts.width - opts.area[1] + 10 &&
    currentPoints.x >= opts.area[3] - 10 &&
    currentPoints.y >= opts.area[0] &&
    currentPoints.y <= opts.height - opts.area[2]
  )
}

function findRadarChartCurrentIndex(currentPoints, radarData, count) {
  var eachAngleArea = (2 * Math.PI) / count
  var currentIndex = -1
  if (isInExactPieChartArea(currentPoints, radarData.center, radarData.radius)) {
    var fixAngle = function fixAngle(angle) {
      if (angle < 0) {
        angle += 2 * Math.PI
      }
      if (angle > 2 * Math.PI) {
        angle -= 2 * Math.PI
      }
      return angle
    }
    var angle = Math.atan2(
      radarData.center.y - currentPoints.y,
      currentPoints.x - radarData.center.x
    )
    angle = -1 * angle
    if (angle < 0) {
      angle += 2 * Math.PI
    }
    var angleList = radarData.angleList.map(function (item) {
      item = fixAngle(-1 * item)
      return item
    })
    angleList.forEach(function (item, index) {
      var rangeStart = fixAngle(item - eachAngleArea / 2)
      var rangeEnd = fixAngle(item + eachAngleArea / 2)
      if (rangeEnd < rangeStart) {
        rangeEnd += 2 * Math.PI
      }
      if (
        (angle >= rangeStart && angle <= rangeEnd) ||
        (angle + 2 * Math.PI >= rangeStart && angle + 2 * Math.PI <= rangeEnd)
      ) {
        currentIndex = index
      }
    })
  }
  return currentIndex
}

function findFunnelChartCurrentIndex(currentPoints, funnelData) {
  var currentIndex = -1
  for (var i = 0, len = funnelData.series.length; i < len; i++) {
    var item = funnelData.series[i]
    if (
      currentPoints.x > item.funnelArea[0] &&
      currentPoints.x < item.funnelArea[2] &&
      currentPoints.y > item.funnelArea[1] &&
      currentPoints.y < item.funnelArea[3]
    ) {
      currentIndex = i
      break
    }
  }
  return currentIndex
}

function findWordChartCurrentIndex(currentPoints, wordData) {
  var currentIndex = -1
  for (var i = 0, len = wordData.length; i < len; i++) {
    var item = wordData[i]
    if (
      currentPoints.x > item.area[0] &&
      currentPoints.x < item.area[2] &&
      currentPoints.y > item.area[1] &&
      currentPoints.y < item.area[3]
    ) {
      currentIndex = i
      break
    }
  }
  return currentIndex
}

function findMapChartCurrentIndex(currentPoints, opts) {
  var currentIndex = -1
  var cData = opts.chartData.mapData
  var data = opts.series
  var tmp = pointToCoordinate(
    currentPoints.y,
    currentPoints.x,
    cData.bounds,
    cData.scale,
    cData.xoffset,
    cData.yoffset
  )
  var poi = [tmp.x, tmp.y]
  for (var i = 0, len = data.length; i < len; i++) {
    var item = data[i].geometry.coordinates
    if (isPoiWithinPoly(poi, item, opts.chartData.mapData.mercator)) {
      currentIndex = i
      break
    }
  }
  return currentIndex
}

function findRoseChartCurrentIndex(currentPoints, pieData, opts) {
  var currentIndex = -1
  var series = getRoseDataPoints(
    opts._series_,
    opts.extra.rose.type,
    pieData.radius,
    pieData.radius
  )
  if (
    pieData &&
    pieData.center &&
    isInExactPieChartArea(currentPoints, pieData.center, pieData.radius)
  ) {
    var angle = Math.atan2(pieData.center.y - currentPoints.y, currentPoints.x - pieData.center.x)
    angle = -angle
    if (opts.extra.rose && opts.extra.rose.offsetAngle) {
      angle = angle - (opts.extra.rose.offsetAngle * Math.PI) / 180
    }
    for (var i = 0, len = series.length; i < len; i++) {
      if (
        isInAngleRange(
          angle,
          series[i]._start_,
          series[i]._start_ + series[i]._rose_proportion_ * 2 * Math.PI
        )
      ) {
        currentIndex = i
        break
      }
    }
  }
  return currentIndex
}

function findPieChartCurrentIndex(currentPoints, pieData, opts) {
  var currentIndex = -1
  var series = getPieDataPoints(pieData.series)
  if (
    pieData &&
    pieData.center &&
    isInExactPieChartArea(currentPoints, pieData.center, pieData.radius)
  ) {
    var angle = Math.atan2(pieData.center.y - currentPoints.y, currentPoints.x - pieData.center.x)
    angle = -angle
    if (opts.extra.pie && opts.extra.pie.offsetAngle) {
      angle = angle - (opts.extra.pie.offsetAngle * Math.PI) / 180
    }
    if (opts.extra.ring && opts.extra.ring.offsetAngle) {
      angle = angle - (opts.extra.ring.offsetAngle * Math.PI) / 180
    }
    for (var i = 0, len = series.length; i < len; i++) {
      if (
        isInAngleRange(
          angle,
          series[i]._start_,
          series[i]._start_ + series[i]._proportion_ * 2 * Math.PI
        )
      ) {
        currentIndex = i
        break
      }
    }
  }
  return currentIndex
}

function isInExactPieChartArea(currentPoints, center, radius) {
  return (
    Math.pow(currentPoints.x - center.x, 2) + Math.pow(currentPoints.y - center.y, 2) <=
    Math.pow(radius, 2)
  )
}

function splitPoints(points, eachSeries) {
  var newPoints = []
  var items = []
  points.forEach(function (item, index) {
    if (eachSeries.connectNulls) {
      if (item !== null) {
        items.push(item)
      }
    } else {
      if (item !== null) {
        items.push(item)
      } else {
        if (items.length) {
          newPoints.push(items)
        }
        items = []
      }
    }
  })
  if (items.length) {
    newPoints.push(items)
  }
  return newPoints
}

function calLegendData(series, opts, config, chartData, context) {
  let legendData = {
    area: {
      start: {
        x: 0,
        y: 0
      },
      end: {
        x: 0,
        y: 0
      },
      width: 0,
      height: 0,
      wholeWidth: 0,
      wholeHeight: 0
    },
    points: [],
    widthArr: [],
    heightArr: []
  }
  if (opts.legend.show === false) {
    chartData.legendData = legendData
    return legendData
  }
  let padding = opts.legend.padding * opts.pix
  let margin = opts.legend.margin * opts.pix
  let fontSize = opts.legend.fontSize ? opts.legend.fontSize * opts.pix : config.fontSize
  let shapeWidth = 15 * opts.pix
  let shapeRight = 5 * opts.pix
  let lineHeight = Math.max(opts.legend.lineHeight * opts.pix, fontSize)
  if (opts.legend.position == 'top' || opts.legend.position == 'bottom') {
    let legendList = []
    let widthCount = 0
    let widthCountArr = []
    let currentRow = []
    for (let i = 0; i < series.length; i++) {
      let item = series[i]
      const legendText = item.legendText ? item.legendText : item.name
      let itemWidth =
        shapeWidth +
        shapeRight +
        measureText(legendText || 'undefined', fontSize, context) +
        opts.legend.itemGap * opts.pix
      if (widthCount + itemWidth > opts.width - opts.area[1] - opts.area[3]) {
        legendList.push(currentRow)
        widthCountArr.push(widthCount - opts.legend.itemGap * opts.pix)
        widthCount = itemWidth
        currentRow = [item]
      } else {
        widthCount += itemWidth
        currentRow.push(item)
      }
    }
    if (currentRow.length) {
      legendList.push(currentRow)
      widthCountArr.push(widthCount - opts.legend.itemGap * opts.pix)
      legendData.widthArr = widthCountArr
      let legendWidth = Math.max.apply(null, widthCountArr)
      switch (opts.legend.float) {
        case 'left':
          legendData.area.start.x = opts.area[3]
          legendData.area.end.x = opts.area[3] + legendWidth + 2 * padding
          break
        case 'right':
          legendData.area.start.x = opts.width - opts.area[1] - legendWidth - 2 * padding
          legendData.area.end.x = opts.width - opts.area[1]
          break
        default:
          legendData.area.start.x = (opts.width - legendWidth) / 2 - padding
          legendData.area.end.x = (opts.width + legendWidth) / 2 + padding
      }
      legendData.area.width = legendWidth + 2 * padding
      legendData.area.wholeWidth = legendWidth + 2 * padding
      legendData.area.height = legendList.length * lineHeight + 2 * padding
      legendData.area.wholeHeight = legendList.length * lineHeight + 2 * padding + 2 * margin
      legendData.points = legendList
    }
  } else {
    let len = series.length
    let maxHeight = opts.height - opts.area[0] - opts.area[2] - 2 * margin - 2 * padding
    let maxLength = Math.min(Math.floor(maxHeight / lineHeight), len)
    legendData.area.height = maxLength * lineHeight + padding * 2
    legendData.area.wholeHeight = maxLength * lineHeight + padding * 2
    switch (opts.legend.float) {
      case 'top':
        legendData.area.start.y = opts.area[0] + margin
        legendData.area.end.y = opts.area[0] + margin + legendData.area.height
        break
      case 'bottom':
        legendData.area.start.y = opts.height - opts.area[2] - margin - legendData.area.height
        legendData.area.end.y = opts.height - opts.area[2] - margin
        break
      default:
        legendData.area.start.y = (opts.height - legendData.area.height) / 2
        legendData.area.end.y = (opts.height + legendData.area.height) / 2
    }
    let lineNum = len % maxLength === 0 ? len / maxLength : Math.floor(len / maxLength + 1)
    let currentRow = []
    for (let i = 0; i < lineNum; i++) {
      let temp = series.slice(i * maxLength, i * maxLength + maxLength)
      currentRow.push(temp)
    }
    legendData.points = currentRow
    if (currentRow.length) {
      for (let i = 0; i < currentRow.length; i++) {
        let item = currentRow[i]
        let maxWidth = 0
        for (let j = 0; j < item.length; j++) {
          let itemWidth =
            shapeWidth +
            shapeRight +
            measureText(item[j].name || 'undefined', fontSize, context) +
            opts.legend.itemGap * opts.pix
          if (itemWidth > maxWidth) {
            maxWidth = itemWidth
          }
        }
        legendData.widthArr.push(maxWidth)
        legendData.heightArr.push(item.length * lineHeight + padding * 2)
      }
      let legendWidth = 0
      for (let i = 0; i < legendData.widthArr.length; i++) {
        legendWidth += legendData.widthArr[i]
      }
      legendData.area.width = legendWidth - opts.legend.itemGap * opts.pix + 2 * padding
      legendData.area.wholeWidth = legendData.area.width + padding
    }
  }
  switch (opts.legend.position) {
    case 'top':
      legendData.area.start.y = opts.area[0] + margin
      legendData.area.end.y = opts.area[0] + margin + legendData.area.height
      break
    case 'bottom':
      legendData.area.start.y = opts.height - opts.area[2] - legendData.area.height - margin
      legendData.area.end.y = opts.height - opts.area[2] - margin
      break
    case 'left':
      legendData.area.start.x = opts.area[3]
      legendData.area.end.x = opts.area[3] + legendData.area.width
      break
    case 'right':
      legendData.area.start.x = opts.width - opts.area[1] - legendData.area.width
      legendData.area.end.x = opts.width - opts.area[1]
      break
  }
  chartData.legendData = legendData
  return legendData
}

function calCategoriesData(categories, opts, config, eachSpacing, context) {
  var result = {
    angle: 0,
    xAxisHeight: opts.xAxis.lineHeight * opts.pix + opts.xAxis.marginTop * opts.pix
  }
  var fontSize = opts.xAxis.fontSize * opts.pix
  var categoriesTextLenth = categories.map(function (item, index) {
    var xitem = opts.xAxis.formatter ? opts.xAxis.formatter(item, index, opts) : item
    return measureText(String(xitem), fontSize, context)
  })
  var maxTextLength = Math.max.apply(this, categoriesTextLenth)
  if (opts.xAxis.rotateLabel == true) {
    result.angle = (opts.xAxis.rotateAngle * Math.PI) / 180
    let tempHeight =
      opts.xAxis.marginTop * opts.pix * 2 + Math.abs(maxTextLength * Math.sin(result.angle))
    tempHeight =
      tempHeight < fontSize + opts.xAxis.marginTop * opts.pix * 2
        ? tempHeight + opts.xAxis.marginTop * opts.pix * 2
        : tempHeight
    result.xAxisHeight = tempHeight
  }
  if (opts.enableScroll && opts.xAxis.scrollShow) {
    result.xAxisHeight += 6 * opts.pix
  }
  if (opts.xAxis.disabled) {
    result.xAxisHeight = 0
  }
  return result
}

function getXAxisTextList(series, opts, config, stack) {
  var index = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1
  var data
  if (stack == 'stack') {
    data = dataCombineStack(series, opts.categories.length)
  } else {
    data = dataCombine(series)
  }
  var sorted = []
  // remove null from data
  data = data.filter(function (item) {
    //return item !== null;
    if (typeof item === 'object' && item !== null) {
      if (item.constructor.toString().indexOf('Array') > -1) {
        return item !== null
      } else {
        return item.value !== null
      }
    } else {
      return item !== null
    }
  })
  data.map(function (item) {
    if (typeof item === 'object') {
      if (item.constructor.toString().indexOf('Array') > -1) {
        if (opts.type == 'candle') {
          item.map(function (subitem) {
            sorted.push(subitem)
          })
        } else {
          sorted.push(item[0])
        }
      } else {
        sorted.push(item.value)
      }
    } else {
      sorted.push(item)
    }
  })

  var minData = 0
  var maxData = 0
  if (sorted.length > 0) {
    if (series.type === 'area-range') {
      // 上下限数据合并
      let allValues = (series.upperData || []).concat(series.lowerData || [])
      minData = Math.min.apply(this, allValues)
      maxData = Math.max.apply(this, allValues)
    } else {
      minData = Math.min.apply(this, sorted)
      maxData = Math.max.apply(this, sorted)
    }
    // minData = Math.min.apply(this, sorted);
    // maxData = Math.max.apply(this, sorted);
  }
  //为了兼容v1.9.0之前的项目
  if (index > -1) {
    if (typeof opts.xAxis.data[index].min === 'number') {
      minData = Math.min(opts.xAxis.data[index].min, minData)
    }
    if (typeof opts.xAxis.data[index].max === 'number') {
      maxData = Math.max(opts.xAxis.data[index].max, maxData)
    }
  } else {
    if (typeof opts.xAxis.min === 'number') {
      minData = Math.min(opts.xAxis.min, minData)
    }
    if (typeof opts.xAxis.max === 'number') {
      maxData = Math.max(opts.xAxis.max, maxData)
    }
  }
  if (minData === maxData) {
    var rangeSpan = maxData || 10
    maxData += rangeSpan
  }
  //var dataRange = getDataRange(minData, maxData);
  var minRange = minData
  var maxRange = maxData
  var range = []
  var eachRange = (maxRange - minRange) / opts.xAxis.splitNumber
  for (var i = 0; i <= opts.xAxis.splitNumber; i++) {
    range.push(minRange + eachRange * i)
  }
  return range
}

function calXAxisData(series, opts, config, context) {
  //堆叠图重算Y轴
  var columnstyle = assign(
    {},
    {
      type: ''
    },
    opts.extra.bar
  )
  var result = {
    angle: 0,
    xAxisHeight: opts.xAxis.lineHeight * opts.pix + opts.xAxis.marginTop * opts.pix
  }
  result.ranges = getXAxisTextList(series, opts, config, columnstyle.type)
  result.rangesFormat = result.ranges.map(function (item) {
    //item = opts.xAxis.formatter ? opts.xAxis.formatter(item) : util.toFixed(item, 2);
    item = util.toFixed(item, 2)
    return item
  })
  var xAxisScaleValues = result.ranges.map(function (item) {
    // 如果刻度值是浮点数,则保留两位小数
    item = util.toFixed(item, 2)
    // 若有自定义格式则调用自定义的格式化函数
    //item = opts.xAxis.formatter ? opts.xAxis.formatter(Number(item)) : item;
    return item
  })
  result = Object.assign(result, getXAxisPoints(xAxisScaleValues, opts, config))
  // 计算X轴刻度的属性譬如每个刻度的间隔,刻度的起始点\结束点以及总长
  var eachSpacing = result.eachSpacing
  var textLength = xAxisScaleValues.map(function (item) {
    return measureText(item, opts.xAxis.fontSize * opts.pix, context)
  })
  if (opts.xAxis.disabled === true) {
    result.xAxisHeight = 0
  }
  return result
}

function getRadarDataPoints(angleList, center, radius, series, opts) {
  var process = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
  var radarOption = opts.extra.radar || {}
  radarOption.max = radarOption.max || 0
  var maxData = Math.max(radarOption.max, Math.max.apply(null, dataCombine(series)))
  var data = []
  for (let i = 0; i < series.length; i++) {
    let each = series[i]
    let listItem = {}
    listItem.color = each.color
    listItem.legendShape = each.legendShape
    listItem.pointShape = each.pointShape
    listItem.data = []
    each.data.forEach(function (item, index) {
      let tmp = {}
      tmp.angle = angleList[index]
      tmp.proportion = item / maxData
      tmp.value = item
      tmp.position = convertCoordinateOrigin(
        radius * tmp.proportion * process * Math.cos(tmp.angle),
        radius * tmp.proportion * process * Math.sin(tmp.angle),
        center
      )
      listItem.data.push(tmp)
    })
    data.push(listItem)
  }
  return data
}

function getPieDataPoints(series, radius) {
  var process = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
  var count = 0
  var _start_ = 0
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    count += item.data
  }
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    if (count === 0) {
      item._proportion_ = (1 / series.length) * process
    } else {
      item._proportion_ = (item.data / count) * process
    }
    item._radius_ = radius
  }
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item._start_ = _start_
    _start_ += 2 * item._proportion_ * Math.PI
  }
  return series
}

function getFunnelDataPoints(series, radius, option, eachSpacing) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  for (let i = 0; i < series.length; i++) {
    if (option.type == 'funnel') {
      series[i].radius = (series[i].data / series[0].data) * radius * process
    } else {
      series[i].radius =
        ((eachSpacing * (series.length - i)) / (eachSpacing * series.length)) * radius * process
    }
    series[i]._proportion_ = series[i].data / series[0].data
  }
  // if(option.type !== 'pyramid'){
  //   series.reverse();
  // }
  return series
}

function getRoseDataPoints(series, type, minRadius, radius) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var count = 0
  var _start_ = 0
  var dataArr = []
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    count += item.data
    dataArr.push(item.data)
  }
  var minData = Math.min.apply(null, dataArr)
  var maxData = Math.max.apply(null, dataArr)
  var radiusLength = radius - minRadius
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    if (count === 0) {
      item._proportion_ = (1 / series.length) * process
      item._rose_proportion_ = (1 / series.length) * process
    } else {
      item._proportion_ = (item.data / count) * process
      if (type == 'area') {
        item._rose_proportion_ = (1 / series.length) * process
      } else {
        item._rose_proportion_ = (item.data / count) * process
      }
    }
    item._radius_ =
      minRadius + radiusLength * ((item.data - minData) / (maxData - minData)) || radius
  }
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item._start_ = _start_
    _start_ += 2 * item._rose_proportion_ * Math.PI
  }
  return series
}

function getArcbarDataPoints(series, arcbarOption) {
  var process = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
  if (process == 1) {
    process = 0.999999
  }
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    let totalAngle
    if (arcbarOption.type == 'circle') {
      totalAngle = 2
    } else {
      if (arcbarOption.direction == 'ccw') {
        if (arcbarOption.startAngle < arcbarOption.endAngle) {
          totalAngle = 2 + arcbarOption.startAngle - arcbarOption.endAngle
        } else {
          totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
        }
      } else {
        if (arcbarOption.endAngle < arcbarOption.startAngle) {
          totalAngle = 2 + arcbarOption.endAngle - arcbarOption.startAngle
        } else {
          totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
        }
      }
    }
    item._proportion_ = totalAngle * item.data * process + arcbarOption.startAngle
    if (arcbarOption.direction == 'ccw') {
      item._proportion_ = arcbarOption.startAngle - totalAngle * item.data * process
    }
    if (item._proportion_ >= 2) {
      item._proportion_ = item._proportion_ % 2
    }
  }
  return series
}

function getGaugeArcbarDataPoints(series, arcbarOption) {
  var process = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
  if (process == 1) {
    process = 0.999999
  }
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    let totalAngle
    if (arcbarOption.type == 'circle') {
      totalAngle = 2
    } else {
      if (arcbarOption.endAngle < arcbarOption.startAngle) {
        totalAngle = 2 + arcbarOption.endAngle - arcbarOption.startAngle
      } else {
        totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
      }
    }
    item._proportion_ = totalAngle * item.data * process + arcbarOption.startAngle
    if (item._proportion_ >= 2) {
      item._proportion_ = item._proportion_ % 2
    }
  }
  return series
}

function getGaugeAxisPoints(categories, startAngle, endAngle) {
  let totalAngle
  if (endAngle < startAngle) {
    totalAngle = 2 + endAngle - startAngle
  } else {
    totalAngle = startAngle - endAngle
  }
  let tempStartAngle = startAngle
  for (let i = 0; i < categories.length; i++) {
    categories[i].value = categories[i].value === null ? 0 : categories[i].value
    categories[i]._startAngle_ = tempStartAngle
    categories[i]._endAngle_ = totalAngle * categories[i].value + startAngle
    if (categories[i]._endAngle_ >= 2) {
      categories[i]._endAngle_ = categories[i]._endAngle_ % 2
    }
    tempStartAngle = categories[i]._endAngle_
  }
  return categories
}

function getGaugeDataPoints(series, categories, gaugeOption) {
  let process = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    item.data = item.data === null ? 0 : item.data
    if (gaugeOption.pointer.color == 'auto') {
      for (let i = 0; i < categories.length; i++) {
        if (item.data <= categories[i].value) {
          item.color = categories[i].color
          break
        }
      }
    } else {
      item.color = gaugeOption.pointer.color
    }
    let totalAngle
    if (gaugeOption.endAngle < gaugeOption.startAngle) {
      totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
    } else {
      totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
    }
    item._endAngle_ = totalAngle * item.data + gaugeOption.startAngle
    item._oldAngle_ = gaugeOption.oldAngle
    if (gaugeOption.oldAngle < gaugeOption.endAngle) {
      item._oldAngle_ += 2
    }
    if (item.data >= gaugeOption.oldData) {
      item._proportion_ = (item._endAngle_ - item._oldAngle_) * process + gaugeOption.oldAngle
    } else {
      item._proportion_ = item._oldAngle_ - (item._oldAngle_ - item._endAngle_) * process
    }
    if (item._proportion_ >= 2) {
      item._proportion_ = item._proportion_ % 2
    }
  }
  return series
}

function getPieTextMaxLength(series, config, context, opts) {
  series = getPieDataPoints(series)
  let maxLength = 0
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    let text = item.formatter
      ? item.formatter(+item._proportion_.toFixed(2))
      : util.toFixed(item._proportion_ * 100) + '%'
    maxLength = Math.max(
      maxLength,
      measureText(text, item.textSize * opts.pix || config.fontSize, context)
    )
  }
  return maxLength
}

function fixColumeData(points, eachSpacing, columnLen, index, config, opts) {
  return points.map(function (item) {
    if (item === null) {
      return null
    }
    var seriesGap = 0
    var categoryGap = 0
    if (opts.type == 'mix') {
      seriesGap = opts.extra.mix.column.seriesGap * opts.pix || 0
      categoryGap = opts.extra.mix.column.categoryGap * opts.pix || 0
    } else {
      seriesGap = opts.extra.column.seriesGap * opts.pix || 0
      categoryGap = opts.extra.column.categoryGap * opts.pix || 0
    }
    seriesGap = Math.min(seriesGap, eachSpacing / columnLen)
    categoryGap = Math.min(categoryGap, eachSpacing / columnLen)
    item.width = Math.ceil(
      (eachSpacing - 2 * categoryGap - seriesGap * (columnLen - 1)) / columnLen
    )
    if (opts.extra.mix && opts.extra.mix.column.width && +opts.extra.mix.column.width > 0) {
      item.width = Math.min(item.width, +opts.extra.mix.column.width * opts.pix)
    }
    if (opts.extra.column && opts.extra.column.width && +opts.extra.column.width > 0) {
      item.width = Math.min(item.width, +opts.extra.column.width * opts.pix)
    }
    if (item.width <= 0) {
      item.width = 1
    }
    item.x += (index + 0.5 - columnLen / 2) * (item.width + seriesGap)
    return item
  })
}

function fixBarData(points, eachSpacing, columnLen, index, config, opts) {
  return points.map(function (item) {
    if (item === null) {
      return null
    }
    var seriesGap = 0
    var categoryGap = 0
    seriesGap = opts.extra.bar.seriesGap * opts.pix || 0
    categoryGap = opts.extra.bar.categoryGap * opts.pix || 0
    seriesGap = Math.min(seriesGap, eachSpacing / columnLen)
    categoryGap = Math.min(categoryGap, eachSpacing / columnLen)
    item.width = Math.ceil(
      (eachSpacing - 2 * categoryGap - seriesGap * (columnLen - 1)) / columnLen
    )
    if (opts.extra.bar && opts.extra.bar.width && +opts.extra.bar.width > 0) {
      item.width = Math.min(item.width, +opts.extra.bar.width * opts.pix)
    }
    if (item.width <= 0) {
      item.width = 1
    }
    item.y += (index + 0.5 - columnLen / 2) * (item.width + seriesGap)
    return item
  })
}

function fixColumeMeterData(points, eachSpacing, columnLen, index, config, opts, border) {
  var categoryGap = opts.extra.column.categoryGap * opts.pix || 0
  return points.map(function (item) {
    if (item === null) {
      return null
    }
    item.width = eachSpacing - 2 * categoryGap
    if (opts.extra.column && opts.extra.column.width && +opts.extra.column.width > 0) {
      item.width = Math.min(item.width, +opts.extra.column.width * opts.pix)
    }
    if (index > 0) {
      item.width -= border
    }
    return item
  })
}

function fixColumeStackData(points, eachSpacing, columnLen, index, config, opts, series) {
  var categoryGap = opts.extra.column.categoryGap * opts.pix || 0
  return points.map(function (item, indexn) {
    if (item === null) {
      return null
    }
    item.width = Math.ceil(eachSpacing - 2 * categoryGap)
    if (opts.extra.column && opts.extra.column.width && +opts.extra.column.width > 0) {
      item.width = Math.min(item.width, +opts.extra.column.width * opts.pix)
    }
    if (item.width <= 0) {
      item.width = 1
    }
    return item
  })
}

function fixBarStackData(points, eachSpacing, columnLen, index, config, opts, series) {
  var categoryGap = opts.extra.bar.categoryGap * opts.pix || 0
  return points.map(function (item, indexn) {
    if (item === null) {
      return null
    }
    item.width = Math.ceil(eachSpacing - 2 * categoryGap)
    if (opts.extra.bar && opts.extra.bar.width && +opts.extra.bar.width > 0) {
      item.width = Math.min(item.width, +opts.extra.bar.width * opts.pix)
    }
    if (item.width <= 0) {
      item.width = 1
    }
    return item
  })
}

function getXAxisPoints(categories, opts, config) {
  var spacingValid = opts.width - opts.area[1] - opts.area[3]
  var dataCount = opts.enableScroll
    ? Math.min(opts.xAxis.itemCount, categories.length)
    : categories.length
  if (
    (opts.type == 'line' ||
      opts.type == 'area' ||
      opts.type == 'scatter' ||
      opts.type == 'bubble' ||
      opts.type == 'bar') &&
    dataCount > 1 &&
    opts.xAxis.boundaryGap == 'justify'
  ) {
    dataCount -= 1
  }
  var widthRatio = 0
  if (
    opts.type == 'mount' &&
    opts.extra &&
    opts.extra.mount &&
    opts.extra.mount.widthRatio &&
    opts.extra.mount.widthRatio > 1
  ) {
    if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
    widthRatio = opts.extra.mount.widthRatio - 1
    dataCount += widthRatio
  }
  var eachSpacing = spacingValid / dataCount
  var xAxisPoints = []
  var startX = opts.area[3]
  var endX = opts.width - opts.area[1]
  categories.forEach(function (item, index) {
    xAxisPoints.push(startX + (widthRatio / 2) * eachSpacing + index * eachSpacing)
  })
  if (opts.xAxis.boundaryGap !== 'justify') {
    if (opts.enableScroll === true) {
      xAxisPoints.push(startX + widthRatio * eachSpacing + categories.length * eachSpacing)
    } else {
      xAxisPoints.push(endX)
    }
  }
  return {
    xAxisPoints: xAxisPoints,
    startX: startX,
    endX: endX,
    eachSpacing: eachSpacing
  }
}

function getCandleDataPoints(data, minRange, maxRange, xAxisPoints, eachSpacing, opts, config) {
  var process = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var cPoints = []
      item.forEach(function (items, indexs) {
        var point = {}
        point.x = xAxisPoints[index] + Math.round(eachSpacing / 2)
        var value = items.value || items
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        height *= process
        point.y = opts.height - Math.round(height) - opts.area[2]
        cPoints.push(point)
      })
      points.push(cPoints)
    }
  })
  return points
}

function getDataPoints(data, minRange, maxRange, xAxisPoints, eachSpacing, opts, config) {
  var process = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
  var boundaryGap = 'center'
  if (
    opts.type == 'line' ||
    opts.type == 'area' ||
    opts.type == 'scatter' ||
    opts.type == 'bubble'
  ) {
    boundaryGap = opts.xAxis.boundaryGap
  }
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  var validWidth = opts.width - opts.area[1] - opts.area[3]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.x = xAxisPoints[index]
      var value = item
      if (typeof item === 'object' && item !== null) {
        if (item.constructor.toString().indexOf('Array') > -1) {
          let xranges, xminRange, xmaxRange
          xranges = [].concat(opts.chartData.xAxisData.ranges)
          xminRange = xranges.shift()
          xmaxRange = xranges.pop()
          value = item[1]
          point.x = opts.area[3] + (validWidth * (item[0] - xminRange)) / (xmaxRange - xminRange)
          if (opts.type == 'bubble') {
            point.r = item[2]
            point.t = item[3]
          }
        } else {
          value = item.value
        }
      }
      if (boundaryGap == 'center') {
        point.x += eachSpacing / 2
      }
      var height = (validHeight * (value - minRange)) / (maxRange - minRange)
      height *= process
      point.y = opts.height - height - opts.area[2]
      points.push(point)
    }
  })
  return points
}

function getLineDataPoints(
  data,
  minRange,
  maxRange,
  xAxisPoints,
  eachSpacing,
  opts,
  config,
  lineOption,
  process
) {
  var process = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
  var boundaryGap = opts.xAxis.boundaryGap
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  var validWidth = opts.width - opts.area[1] - opts.area[3]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      if (lineOption.animation == 'vertical') {
        point.x = xAxisPoints[index]
        var value = item
        if (typeof item === 'object' && item !== null) {
          if (item.constructor.toString().indexOf('Array') > -1) {
            let xranges, xminRange, xmaxRange
            xranges = [].concat(opts.chartData.xAxisData.ranges)
            xminRange = xranges.shift()
            xmaxRange = xranges.pop()
            value = item[1]
            point.x = opts.area[3] + (validWidth * (item[0] - xminRange)) / (xmaxRange - xminRange)
          } else {
            value = item.value
          }
        }
        if (boundaryGap == 'center') {
          point.x += eachSpacing / 2
        }
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        height *= process
        point.y = opts.height - height - opts.area[2]
        points.push(point)
      } else {
        point.x = xAxisPoints[0] + eachSpacing * index * process
        var value = item
        if (boundaryGap == 'center') {
          point.x += eachSpacing / 2
        }
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        point.y = opts.height - height - opts.area[2]
        points.push(point)
      }
    }
  })
  return points
}

function getColumnDataPoints(
  data,
  minRange,
  maxRange,
  xAxisPoints,
  eachSpacing,
  opts,
  config,
  zeroPoints,
  process
) {
  var process = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  var validWidth = opts.width - opts.area[1] - opts.area[3]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.x = xAxisPoints[index]
      var value = item
      if (typeof item === 'object' && item !== null) {
        if (item.constructor.toString().indexOf('Array') > -1) {
          let xranges, xminRange, xmaxRange
          xranges = [].concat(opts.chartData.xAxisData.ranges)
          xminRange = xranges.shift()
          xmaxRange = xranges.pop()
          value = item[1]
          point.x = opts.area[3] + (validWidth * (item[0] - xminRange)) / (xmaxRange - xminRange)
        } else {
          value = item.value
        }
      }
      point.x += eachSpacing / 2
      var height = (validHeight * (value * process - minRange)) / (maxRange - minRange)
      point.y = opts.height - height - opts.area[2]
      points.push(point)
    }
  })
  return points
}

function getMountDataPoints(
  series,
  minRange,
  maxRange,
  xAxisPoints,
  eachSpacing,
  opts,
  mountOption,
  zeroPoints
) {
  var process = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  var validWidth = opts.width - opts.area[1] - opts.area[3]
  var mountWidth = eachSpacing * mountOption.widthRatio
  series.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.x = xAxisPoints[index]
      point.x += eachSpacing / 2
      var value = item.data
      var height = (validHeight * (value * process - minRange)) / (maxRange - minRange)
      point.y = opts.height - height - opts.area[2]
      point.value = value
      point.width = mountWidth
      points.push(point)
    }
  })
  return points
}

function getBarDataPoints(data, minRange, maxRange, yAxisPoints, eachSpacing, opts, config) {
  var process = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  var validWidth = opts.width - opts.area[1] - opts.area[3]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.y = yAxisPoints[index]
      var value = item
      if (typeof item === 'object' && item !== null) {
        value = item.value
      }
      var height = (validWidth * (value - minRange)) / (maxRange - minRange)
      height *= process
      point.height = height
      point.value = value
      point.x = height + opts.area[3]
      points.push(point)
    }
  })
  return points
}

function getStackDataPoints(
  data,
  minRange,
  maxRange,
  xAxisPoints,
  eachSpacing,
  opts,
  config,
  seriesIndex,
  stackSeries
) {
  var process = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 1
  var points = []
  var validHeight = opts.height - opts.area[0] - opts.area[2]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.x = xAxisPoints[index] + Math.round(eachSpacing / 2)

      if (seriesIndex > 0) {
        var value = 0
        for (let i = 0; i <= seriesIndex; i++) {
          value += stackSeries[i].data[index]
        }
        var value0 = value - item
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        var height0 = (validHeight * (value0 - minRange)) / (maxRange - minRange)
      } else {
        var value = item
        if (typeof item === 'object' && item !== null) {
          value = item.value
        }
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        var height0 = 0
      }
      var heightc = height0
      height *= process
      heightc *= process
      point.y = opts.height - Math.round(height) - opts.area[2]
      point.y0 = opts.height - Math.round(heightc) - opts.area[2]
      points.push(point)
    }
  })
  return points
}

function getBarStackDataPoints(
  data,
  minRange,
  maxRange,
  yAxisPoints,
  eachSpacing,
  opts,
  config,
  seriesIndex,
  stackSeries
) {
  var process = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 1
  var points = []
  var validHeight = opts.width - opts.area[1] - opts.area[3]
  data.forEach(function (item, index) {
    if (item === null) {
      points.push(null)
    } else {
      var point = {}
      point.color = item.color
      point.y = yAxisPoints[index]
      if (seriesIndex > 0) {
        var value = 0
        for (let i = 0; i <= seriesIndex; i++) {
          value += stackSeries[i].data[index]
        }
        var value0 = value - item
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        var height0 = (validHeight * (value0 - minRange)) / (maxRange - minRange)
      } else {
        var value = item
        if (typeof item === 'object' && item !== null) {
          value = item.value
        }
        var height = (validHeight * (value - minRange)) / (maxRange - minRange)
        var height0 = 0
      }
      var heightc = height0
      height *= process
      heightc *= process
      point.height = height - heightc
      point.x = opts.area[3] + height
      point.x0 = opts.area[3] + heightc
      points.push(point)
    }
  })
  return points
}

function getYAxisTextList(series, opts, config, stack, yData) {
  var index = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : -1
  var data
  if (stack == 'stack') {
    data = dataCombineStack(series, opts.categories.length)
  } else {
    data = dataCombine(series)
  }
  var sorted = []
  // remove null from data
  data = data.filter(function (item) {
    //return item !== null;
    if (typeof item === 'object' && item !== null) {
      if (item.constructor.toString().indexOf('Array') > -1) {
        return item !== null
      } else {
        return item.value !== null
      }
    } else {
      return item !== null
    }
  })
  data.map(function (item) {
    const filter = opts.series.filter((item) => item.type == 'area-range')
    if (filter.length) {
      if (item && item.constructor.toString().indexOf('Array') > -1) {
        // item 可能是 [upper, lower]
        item.forEach(function (subitem) {
          if (typeof subitem === 'number' && !isNaN(subitem)) {
            sorted.push(subitem)
          }
        })
      }
      return
    }

    if (typeof item === 'object') {
      if (item.constructor.toString().indexOf('Array') > -1) {
        if (opts.type == 'candle') {
          item.map(function (subitem) {
            sorted.push(subitem)
          })
        } else {
          sorted.push(item[1])
        }
      } else {
        sorted.push(item.value)
      }
    } else {
      sorted.push(item)
    }
  })
  var minData = yData.min || 0
  var maxData = yData.max || 0
  if (sorted.length > 0) {
    minData = Math.min.apply(this, sorted)
    maxData = Math.max.apply(this, sorted)
  }
  if (minData === maxData) {
    if (maxData == 0) {
      maxData = 10
    } else {
      minData = 0
    }
  }

  var dataRange = getDataRange(minData, maxData)
  var minRange = yData.min === undefined || yData.min === null ? dataRange.minRange : yData.min
  var maxRange = yData.max === undefined || yData.max === null ? dataRange.maxRange : yData.max
  var eachRange = (maxRange - minRange) / opts.yAxis.splitNumber
  var range = []
  for (var i = 0; i <= opts.yAxis.splitNumber; i++) {
    range.push(minRange + eachRange * i)
  }
  return range.reverse()
}

function calYAxisData(series, opts, config, context) {
  //堆叠图重算Y轴
  var columnstyle = assign(
    {},
    {
      type: ''
    },
    opts.extra.column
  )
  //如果是多Y轴，重新计算
  var YLength = opts.yAxis.data.length
  var newSeries = new Array(YLength)
  if (YLength > 0) {
    for (let i = 0; i < YLength; i++) {
      newSeries[i] = []
      for (let j = 0; j < series.length; j++) {
        if (series[j].index == i) {
          newSeries[i].push(series[j])
        }
      }
    }
    var rangesArr = new Array(YLength)
    var rangesFormatArr = new Array(YLength)
    var yAxisWidthArr = new Array(YLength)

    for (let i = 0; i < YLength; i++) {
      let yData = opts.yAxis.data[i]
      //如果总开关不显示，强制每个Y轴为不显示
      if (opts.yAxis.disabled == true) {
        yData.disabled = true
      }
      if (yData.type === 'categories') {
        if (!yData.formatter) {
          yData.formatter = (val, index, opts) => {
            return val + (yData.unit || '')
          }
        }
        yData.categories = yData.categories || opts.categories
        rangesArr[i] = yData.categories
      } else {
        if (!yData.formatter) {
          yData.formatter = (val, index, opts) => {
            return util.toFixed(val, yData.tofix || 0) + (yData.unit || '')
          }
        }
        rangesArr[i] = getYAxisTextList(newSeries[i], opts, config, columnstyle.type, yData, i)
      }
      let yAxisFontSizes = yData.fontSize * opts.pix || config.fontSize
      yAxisWidthArr[i] = {
        position: yData.position ? yData.position : 'left',
        width: 0
      }
      rangesFormatArr[i] = rangesArr[i].map(function (items, index) {
        items = yData.formatter(items, index, opts)
        yAxisWidthArr[i].width = Math.max(
          yAxisWidthArr[i].width,
          measureText(items, yAxisFontSizes, context) + 5
        )
        return items
      })
      let calibration = yData.calibration ? 4 * opts.pix : 0
      yAxisWidthArr[i].width += calibration + 3 * opts.pix
      if (yData.disabled === true) {
        yAxisWidthArr[i].width = 0
      }
    }
  } else {
    var rangesArr = new Array(1)
    var rangesFormatArr = new Array(1)
    var yAxisWidthArr = new Array(1)
    if (opts.type === 'bar') {
      rangesArr[0] = opts.categories
      if (!opts.yAxis.formatter) {
        opts.yAxis.formatter = (val, index, opts) => {
          return val + (opts.yAxis.unit || '')
        }
      }
    } else {
      if (!opts.yAxis.formatter) {
        opts.yAxis.formatter = (val, index, opts) => {
          return val.toFixed(opts.yAxis.tofix) + (opts.yAxis.unit || '')
        }
      }
      rangesArr[0] = getYAxisTextList(series, opts, config, columnstyle.type, {})
    }
    yAxisWidthArr[0] = {
      position: 'left',
      width: 0
    }
    var yAxisFontSize = opts.yAxis.fontSize * opts.pix || config.fontSize
    rangesFormatArr[0] = rangesArr[0].map(function (item, index) {
      item = opts.yAxis.formatter(item, index, opts)
      yAxisWidthArr[0].width = Math.max(
        yAxisWidthArr[0].width,
        measureText(item, yAxisFontSize, context) + 5
      )
      return item
    })
    yAxisWidthArr[0].width += 3 * opts.pix
    if (opts.yAxis.disabled === true) {
      yAxisWidthArr[0] = {
        position: 'left',
        width: 0
      }
      opts.yAxis.data[0] = {
        disabled: true
      }
    } else {
      opts.yAxis.data[0] = {
        disabled: false,
        position: 'left',
        max: opts.yAxis.max,
        min: opts.yAxis.min,
        formatter: opts.yAxis.formatter
      }
      if (opts.type === 'bar') {
        opts.yAxis.data[0].categories = opts.categories
        opts.yAxis.data[0].type = 'categories'
      }
    }
  }
  return {
    rangesFormat: rangesFormatArr,
    ranges: rangesArr,
    yAxisWidth: yAxisWidthArr
  }
}

function calTooltipYAxisData(point, series, opts, config, eachSpacing) {
  let ranges = [].concat(opts.chartData.yAxisData.ranges)
  let spacingValid = opts.height - opts.area[0] - opts.area[2]
  let minAxis = opts.area[0]
  let items = []
  for (let i = 0; i < ranges.length; i++) {
    let maxVal = Math.max.apply(this, ranges[i])
    let minVal = Math.min.apply(this, ranges[i])
    let item = maxVal - ((maxVal - minVal) * (point - minAxis)) / spacingValid
    item =
      opts.yAxis.data && opts.yAxis.data[i].formatter
        ? opts.yAxis.data[i].formatter(item, i, opts)
        : item.toFixed(0)
    items.push(String(item))
  }
  return items
}

function calMarkLineData(points, opts) {
  let minRange, maxRange
  let spacingValid = opts.height - opts.area[0] - opts.area[2]
  for (let i = 0; i < points.length; i++) {
    points[i].yAxisIndex = points[i].yAxisIndex ? points[i].yAxisIndex : 0
    let range = [].concat(opts.chartData.yAxisData.ranges[points[i].yAxisIndex])
    minRange = range.pop()
    maxRange = range.shift()
    let height = (spacingValid * (points[i].value - minRange)) / (maxRange - minRange)
    points[i].y = opts.height - Math.round(height) - opts.area[2]
  }
  return points
}

function contextRotate(context, opts) {
  if (opts.rotateLock !== true) {
    context.translate(opts.height, 0)
    context.rotate((90 * Math.PI) / 180)
  } else if (opts._rotate_ !== true) {
    context.translate(opts.height, 0)
    context.rotate((90 * Math.PI) / 180)
    opts._rotate_ = true
  }
}

function drawPointShape(points, color, shape, context, opts) {
  context.beginPath()
  if (opts.dataPointShapeType == 'hollow') {
    context.setStrokeStyle(color)
    context.setFillStyle(opts.background)
    context.setLineWidth(2 * opts.pix)
  } else {
    context.setStrokeStyle('#ffffff')
    context.setFillStyle(color)
    context.setLineWidth(1 * opts.pix)
  }
  if (shape === 'diamond') {
    points.forEach(function (item, index) {
      if (item !== null) {
        context.moveTo(item.x, item.y - 4.5)
        context.lineTo(item.x - 4.5, item.y)
        context.lineTo(item.x, item.y + 4.5)
        context.lineTo(item.x + 4.5, item.y)
        context.lineTo(item.x, item.y - 4.5)
      }
    })
  } else if (shape === 'circle') {
    points.forEach(function (item, index) {
      if (item !== null) {
        context.moveTo(item.x + 2.5 * opts.pix, item.y)
        context.arc(item.x, item.y, 3 * opts.pix, 0, 2 * Math.PI, false)
      }
    })
  } else if (shape === 'square') {
    points.forEach(function (item, index) {
      if (item !== null) {
        context.moveTo(item.x - 3.5, item.y - 3.5)
        context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
      }
    })
  } else if (shape === 'triangle') {
    points.forEach(function (item, index) {
      if (item !== null) {
        context.moveTo(item.x, item.y - 4.5)
        context.lineTo(item.x - 4.5, item.y + 4.5)
        context.lineTo(item.x + 4.5, item.y + 4.5)
        context.lineTo(item.x, item.y - 4.5)
      }
    })
  } else if (shape === 'none') {
    return
  }
  context.closePath()
  context.fill()
  context.stroke()
}

function drawActivePoint(points, color, shape, context, opts, option, seriesIndex) {
  if (!opts.tooltip) {
    return
  }
  if (opts.tooltip.group.length > 0 && opts.tooltip.group.includes(seriesIndex) == false) {
    return
  }
  var pointIndex =
    typeof opts.tooltip.index === 'number'
      ? opts.tooltip.index
      : opts.tooltip.index[opts.tooltip.group.indexOf(seriesIndex)]
  context.beginPath()
  if (option.activeType == 'hollow') {
    context.setStrokeStyle(color)
    context.setFillStyle(opts.background)
    context.setLineWidth(2 * opts.pix)
  } else {
    context.setStrokeStyle('#ffffff')
    context.setFillStyle(color)
    context.setLineWidth(1 * opts.pix)
  }
  if (shape === 'diamond') {
    points.forEach(function (item, index) {
      if (item !== null && pointIndex == index) {
        context.moveTo(item.x, item.y - 4.5)
        context.lineTo(item.x - 4.5, item.y)
        context.lineTo(item.x, item.y + 4.5)
        context.lineTo(item.x + 4.5, item.y)
        context.lineTo(item.x, item.y - 4.5)
      }
    })
  } else if (shape === 'circle') {
    points.forEach(function (item, index) {
      if (item !== null && pointIndex == index) {
        context.moveTo(item.x + 2.5 * opts.pix, item.y)
        context.arc(item.x, item.y, 3 * opts.pix, 0, 2 * Math.PI, false)
      }
    })
  } else if (shape === 'square') {
    points.forEach(function (item, index) {
      if (item !== null && pointIndex == index) {
        context.moveTo(item.x - 3.5, item.y - 3.5)
        context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
      }
    })
  } else if (shape === 'triangle') {
    points.forEach(function (item, index) {
      if (item !== null && pointIndex == index) {
        context.moveTo(item.x, item.y - 4.5)
        context.lineTo(item.x - 4.5, item.y + 4.5)
        context.lineTo(item.x + 4.5, item.y + 4.5)
        context.lineTo(item.x, item.y - 4.5)
      }
    })
  } else if (shape === 'none') {
    return
  }
  context.closePath()
  context.fill()
  context.stroke()
}

function drawRingTitle(opts, config, context, center) {
  var titlefontSize = opts.title.fontSize || config.titleFontSize
  var subtitlefontSize = opts.subtitle.fontSize || config.subtitleFontSize
  var title = opts.title.name || ''
  var subtitle = opts.subtitle.name || ''
  var titleFontColor = opts.title.color || opts.fontColor
  var subtitleFontColor = opts.subtitle.color || opts.fontColor
  var titleHeight = title ? titlefontSize : 0
  var subtitleHeight = subtitle ? subtitlefontSize : 0
  var margin = 5
  if (subtitle) {
    var textWidth = measureText(subtitle, subtitlefontSize * opts.pix, context)
    var startX = center.x - textWidth / 2 + (opts.subtitle.offsetX || 0) * opts.pix
    var startY =
      center.y + (subtitlefontSize * opts.pix) / 2 + (opts.subtitle.offsetY || 0) * opts.pix
    if (title) {
      startY += (titleHeight * opts.pix + margin) / 2
    }
    context.beginPath()
    context.setFontSize(subtitlefontSize * opts.pix)
    context.setFillStyle(subtitleFontColor)
    context.fillText(subtitle, startX, startY)
    context.closePath()
    context.stroke()
  }
  if (title) {
    var _textWidth = measureText(title, titlefontSize * opts.pix, context)
    var _startX = center.x - _textWidth / 2 + (opts.title.offsetX || 0)
    var _startY = center.y + (titlefontSize * opts.pix) / 2 + (opts.title.offsetY || 0) * opts.pix
    if (subtitle) {
      _startY -= (subtitleHeight * opts.pix + margin) / 2
    }
    context.beginPath()
    context.setFontSize(titlefontSize * opts.pix)
    context.setFillStyle(titleFontColor)
    context.fillText(title, _startX, _startY)
    context.closePath()
    context.stroke()
  }
}

function drawPointText(points, series, config, context, opts) {
  // 绘制数据文案
  var data = series.data
  var textOffset = series.textOffset ? series.textOffset : 0
  points.forEach(function (item, index) {
    if (item !== null) {
      context.beginPath()
      var fontSize = series.textSize ? series.textSize * opts.pix : config.fontSize
      context.setFontSize(fontSize)
      context.setFillStyle(series.textColor || opts.fontColor)
      var value = data[index]
      if (typeof data[index] === 'object' && data[index] !== null) {
        if (data[index].constructor.toString().indexOf('Array') > -1) {
          value = data[index][1]
        } else {
          value = data[index].value
        }
      }
      var formatVal = series.formatter ? series.formatter(value, index, series, opts) : value
      context.setTextAlign('center')
      context.fillText(String(formatVal), item.x, item.y - 4 + textOffset * opts.pix)
      context.closePath()
      context.stroke()
      context.setTextAlign('left')
    }
  })
}

function drawColumePointText(points, series, config, context, opts) {
  // 绘制数据文案
  var data = series.data
  var textOffset = series.textOffset ? series.textOffset : 0
  var Position = opts.extra.column.labelPosition
  points.forEach(function (item, index) {
    if (item !== null) {
      context.beginPath()
      var fontSize = series.textSize ? series.textSize * opts.pix : config.fontSize
      context.setFontSize(fontSize)
      context.setFillStyle(series.textColor || opts.fontColor)
      var value = data[index]
      if (typeof data[index] === 'object' && data[index] !== null) {
        if (data[index].constructor.toString().indexOf('Array') > -1) {
          value = data[index][1]
        } else {
          value = data[index].value
        }
      }
      var formatVal = series.formatter ? series.formatter(value, index, series, opts) : value
      context.setTextAlign('center')
      var startY = item.y - 4 * opts.pix + textOffset * opts.pix
      if (item.y > series.zeroPoints) {
        startY = item.y + textOffset * opts.pix + fontSize
      }
      if (Position == 'insideTop') {
        startY = item.y + fontSize + textOffset * opts.pix
        if (item.y > series.zeroPoints) {
          startY = item.y - textOffset * opts.pix - 4 * opts.pix
        }
      }
      if (Position == 'center') {
        startY =
          item.y + textOffset * opts.pix + (opts.height - opts.area[2] - item.y + fontSize) / 2
        if (series.zeroPoints < opts.height - opts.area[2]) {
          startY = item.y + textOffset * opts.pix + (series.zeroPoints - item.y + fontSize) / 2
        }
        if (item.y > series.zeroPoints) {
          startY = item.y - textOffset * opts.pix - (item.y - series.zeroPoints - fontSize) / 2
        }
        if (opts.extra.column.type == 'stack') {
          startY = item.y + textOffset * opts.pix + (item.y0 - item.y + fontSize) / 2
        }
      }
      if (Position == 'bottom') {
        startY = opts.height - opts.area[2] + textOffset * opts.pix - 4 * opts.pix
        if (series.zeroPoints < opts.height - opts.area[2]) {
          startY = series.zeroPoints + textOffset * opts.pix - 4 * opts.pix
        }
        if (item.y > series.zeroPoints) {
          startY = series.zeroPoints - textOffset * opts.pix + fontSize + 2 * opts.pix
        }
        if (opts.extra.column.type == 'stack') {
          startY = item.y0 + textOffset * opts.pix - 4 * opts.pix
        }
      }
      context.fillText(String(formatVal), item.x, startY)
      context.closePath()
      context.stroke()
      context.setTextAlign('left')
    }
  })
}

function drawMountPointText(points, series, config, context, opts, zeroPoints) {
  // 绘制数据文案
  var data = series.data
  var textOffset = series.textOffset ? series.textOffset : 0
  var Position = opts.extra.mount.labelPosition
  points.forEach(function (item, index) {
    if (item !== null) {
      context.beginPath()
      var fontSize = series[index].textSize ? series[index].textSize * opts.pix : config.fontSize
      context.setFontSize(fontSize)
      context.setFillStyle(series[index].textColor || opts.fontColor)
      var value = item.value
      var formatVal = series[index].formatter
        ? series[index].formatter(value, index, series, opts)
        : value
      context.setTextAlign('center')
      var startY = item.y - 4 * opts.pix + textOffset * opts.pix
      if (item.y > zeroPoints) {
        startY = item.y + textOffset * opts.pix + fontSize
      }
      context.fillText(String(formatVal), item.x, startY)
      context.closePath()
      context.stroke()
      context.setTextAlign('left')
    }
  })
}

function drawBarPointText(points, series, config, context, opts) {
  // 绘制数据文案
  var data = series.data
  var textOffset = series.textOffset ? series.textOffset : 0
  points.forEach(function (item, index) {
    if (item !== null) {
      context.beginPath()
      var fontSize = series.textSize ? series.textSize * opts.pix : config.fontSize
      context.setFontSize(fontSize)
      context.setFillStyle(series.textColor || opts.fontColor)
      var value = data[index]
      if (typeof data[index] === 'object' && data[index] !== null) {
        value = data[index].value
      }
      var formatVal = series.formatter ? series.formatter(value, index, series, opts) : value
      context.setTextAlign('left')
      context.fillText(String(formatVal), item.x + 4 * opts.pix, item.y + fontSize / 2 - 3)
      context.closePath()
      context.stroke()
    }
  })
}

function drawGaugeLabel(gaugeOption, radius, centerPosition, opts, config, context) {
  radius -= gaugeOption.width / 2 + gaugeOption.labelOffset * opts.pix
  radius = radius < 10 ? 10 : radius
  let totalAngle
  if (gaugeOption.endAngle < gaugeOption.startAngle) {
    totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
  } else {
    totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
  }
  let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
  let totalNumber = gaugeOption.endNumber - gaugeOption.startNumber
  let splitNumber = totalNumber / gaugeOption.splitLine.splitNumber
  let nowAngle = gaugeOption.startAngle
  let nowNumber = gaugeOption.startNumber
  for (let i = 0; i < gaugeOption.splitLine.splitNumber + 1; i++) {
    var pos = {
      x: radius * Math.cos(nowAngle * Math.PI),
      y: radius * Math.sin(nowAngle * Math.PI)
    }
    var labelText = gaugeOption.formatter ? gaugeOption.formatter(nowNumber, i, opts) : nowNumber
    pos.x += centerPosition.x - measureText(labelText, config.fontSize, context) / 2
    pos.y += centerPosition.y
    var startX = pos.x
    var startY = pos.y
    context.beginPath()
    context.setFontSize(config.fontSize)
    context.setFillStyle(gaugeOption.labelColor || opts.fontColor)
    context.fillText(labelText, startX, startY + config.fontSize / 2)
    context.closePath()
    context.stroke()
    nowAngle += splitAngle
    if (nowAngle >= 2) {
      nowAngle = nowAngle % 2
    }
    nowNumber += splitNumber
  }
}

function drawRadarLabel(angleList, radius, centerPosition, opts, config, context) {
  var radarOption = opts.extra.radar || {}
  angleList.forEach(function (angle, index) {
    if (radarOption.labelPointShow === true && opts.categories[index] !== '') {
      var posPoint = {
        x: radius * Math.cos(angle),
        y: radius * Math.sin(angle)
      }
      var posPointAxis = convertCoordinateOrigin(posPoint.x, posPoint.y, centerPosition)
      context.setFillStyle(radarOption.labelPointColor)
      context.beginPath()
      context.arc(
        posPointAxis.x,
        posPointAxis.y,
        radarOption.labelPointRadius * opts.pix,
        0,
        2 * Math.PI,
        false
      )
      context.closePath()
      context.fill()
    }
    if (radarOption.labelShow === true) {
      var pos = {
        x: (radius + config.radarLabelTextMargin * opts.pix) * Math.cos(angle),
        y: (radius + config.radarLabelTextMargin * opts.pix) * Math.sin(angle)
      }
      var posRelativeCanvas = convertCoordinateOrigin(pos.x, pos.y, centerPosition)
      var startX = posRelativeCanvas.x
      var startY = posRelativeCanvas.y
      if (util.approximatelyEqual(pos.x, 0)) {
        startX -= measureText(opts.categories[index] || '', config.fontSize, context) / 2
      } else if (pos.x < 0) {
        startX -= measureText(opts.categories[index] || '', config.fontSize, context)
      }
      context.beginPath()
      context.setFontSize(config.fontSize)
      context.setFillStyle(radarOption.labelColor || opts.fontColor)
      context.fillText(opts.categories[index] || '', startX, startY + config.fontSize / 2)
      context.closePath()
      context.stroke()
    }
  })
}

function drawPieText(series, opts, config, context, radius, center) {
  var lineRadius = config.pieChartLinePadding
  var textObjectCollection = []
  var lastTextObject = null
  var seriesConvert = series.map(function (item, index) {
    var text = item.formatter
      ? item.formatter(item, index, series, opts)
      : util.toFixed(item._proportion_.toFixed(4) * 100) + '%'
    text = item.labelText ? item.labelText : text
    var arc = 2 * Math.PI - (item._start_ + (2 * Math.PI * item._proportion_) / 2)
    if (item._rose_proportion_) {
      arc = 2 * Math.PI - (item._start_ + (2 * Math.PI * item._rose_proportion_) / 2)
    }
    var color = item.color
    var radius = item._radius_
    return {
      arc: arc,
      text: text,
      color: color,
      radius: radius,
      textColor: item.textColor,
      textSize: item.textSize,
      labelShow: item.labelShow
    }
  })
  for (let i = 0; i < seriesConvert.length; i++) {
    let item = seriesConvert[i]
    // line end
    let orginX1 = Math.cos(item.arc) * (item.radius + lineRadius)
    let orginY1 = Math.sin(item.arc) * (item.radius + lineRadius)
    // line start
    let orginX2 = Math.cos(item.arc) * item.radius
    let orginY2 = Math.sin(item.arc) * item.radius
    // text start
    let orginX3 =
      orginX1 >= 0 ? orginX1 + config.pieChartTextPadding : orginX1 - config.pieChartTextPadding
    let orginY3 = orginY1
    let textWidth = measureText(item.text, item.textSize * opts.pix || config.fontSize, context)
    let startY = orginY3
    if (
      lastTextObject &&
      util.isSameXCoordinateArea(lastTextObject.start, {
        x: orginX3
      })
    ) {
      if (orginX3 > 0) {
        startY = Math.min(orginY3, lastTextObject.start.y)
      } else if (orginX1 < 0) {
        startY = Math.max(orginY3, lastTextObject.start.y)
      } else {
        if (orginY3 > 0) {
          startY = Math.max(orginY3, lastTextObject.start.y)
        } else {
          startY = Math.min(orginY3, lastTextObject.start.y)
        }
      }
    }
    if (orginX3 < 0) {
      orginX3 -= textWidth
    }
    let textObject = {
      lineStart: {
        x: orginX2,
        y: orginY2
      },
      lineEnd: {
        x: orginX1,
        y: orginY1
      },
      start: {
        x: orginX3,
        y: startY
      },
      width: textWidth,
      height: config.fontSize,
      text: item.text,
      color: item.color,
      textColor: item.textColor,
      textSize: item.textSize
    }
    lastTextObject = avoidCollision(textObject, lastTextObject)
    textObjectCollection.push(lastTextObject)
  }
  for (let i = 0; i < textObjectCollection.length; i++) {
    if (seriesConvert[i].labelShow === false) {
      continue
    }
    let item = textObjectCollection[i]
    let lineStartPoistion = convertCoordinateOrigin(item.lineStart.x, item.lineStart.y, center)
    let lineEndPoistion = convertCoordinateOrigin(item.lineEnd.x, item.lineEnd.y, center)
    let textPosition = convertCoordinateOrigin(item.start.x, item.start.y, center)
    context.setLineWidth(1 * opts.pix)
    context.setFontSize(item.textSize * opts.pix || config.fontSize)
    context.beginPath()
    context.setStrokeStyle(item.color)
    context.setFillStyle(item.color)
    context.moveTo(lineStartPoistion.x, lineStartPoistion.y)
    let curveStartX = item.start.x < 0 ? textPosition.x + item.width : textPosition.x
    let textStartX = item.start.x < 0 ? textPosition.x - 5 : textPosition.x + 5
    context.quadraticCurveTo(lineEndPoistion.x, lineEndPoistion.y, curveStartX, textPosition.y)
    context.moveTo(lineStartPoistion.x, lineStartPoistion.y)
    context.stroke()
    context.closePath()
    context.beginPath()
    context.moveTo(textPosition.x + item.width, textPosition.y)
    context.arc(curveStartX, textPosition.y, 2 * opts.pix, 0, 2 * Math.PI)
    context.closePath()
    context.fill()
    context.beginPath()
    context.setFontSize(item.textSize * opts.pix || config.fontSize)
    context.setFillStyle(item.textColor || opts.fontColor)
    context.fillText(item.text, textStartX, textPosition.y + 3)
    context.closePath()
    context.stroke()
    context.closePath()
  }
}

function drawToolTipSplitLine(offsetX, opts, config, context) {
  var toolTipOption = opts.extra.tooltip || {}
  toolTipOption.gridType = toolTipOption.gridType == undefined ? 'solid' : toolTipOption.gridType
  toolTipOption.dashLength = toolTipOption.dashLength == undefined ? 4 : toolTipOption.dashLength
  var startY = opts.area[0]
  var endY = opts.height - opts.area[2]
  if (toolTipOption.gridType == 'dash') {
    context.setLineDash([toolTipOption.dashLength, toolTipOption.dashLength])
  }
  context.setStrokeStyle(toolTipOption.gridColor || '#cccccc')
  context.setLineWidth(1 * opts.pix)
  context.beginPath()
  context.moveTo(offsetX, startY)
  context.lineTo(offsetX, endY)
  context.stroke()
  context.setLineDash([])
  if (toolTipOption.xAxisLabel) {
    let labelText = opts.categories[opts.tooltip.index]
    context.setFontSize(config.fontSize)
    let textWidth = measureText(labelText, config.fontSize, context)
    let textX = offsetX - 0.5 * textWidth
    let textY = endY + 2 * opts.pix
    context.beginPath()
    context.setFillStyle(
      hexToRgb(
        toolTipOption.labelBgColor || config.toolTipBackground,
        toolTipOption.labelBgOpacity || config.toolTipOpacity
      )
    )
    context.setStrokeStyle(toolTipOption.labelBgColor || config.toolTipBackground)
    context.setLineWidth(1 * opts.pix)
    context.rect(
      textX - toolTipOption.boxPadding * opts.pix,
      textY,
      textWidth + 2 * toolTipOption.boxPadding * opts.pix,
      config.fontSize + 2 * toolTipOption.boxPadding * opts.pix
    )
    context.closePath()
    context.stroke()
    context.fill()
    context.beginPath()
    context.setFontSize(config.fontSize)
    context.setFillStyle(toolTipOption.labelFontColor || opts.fontColor)
    context.fillText(
      String(labelText),
      textX,
      textY + toolTipOption.boxPadding * opts.pix + config.fontSize
    )
    context.closePath()
    context.stroke()
  }
}

function drawMarkLine(opts, config, context) {
  let markLineOption = assign(
    {},
    {
      type: 'solid',
      dashLength: 4,
      data: []
    },
    opts.extra.markLine
  )
  let startX = opts.area[3]
  let endX = opts.width - opts.area[1]
  let points = calMarkLineData(markLineOption.data, opts)
  for (let i = 0; i < points.length; i++) {
    let item = assign(
      {},
      {
        lineColor: '#DE4A42',
        showLabel: false,
        labelFontSize: 13,
        labelPadding: 6,
        labelFontColor: '#666666',
        labelBgColor: '#DFE8FF',
        labelBgOpacity: 0.8,
        labelAlign: 'left',
        labelOffsetX: 0,
        labelOffsetY: 0
      },
      points[i]
    )
    if (markLineOption.type == 'dash') {
      context.setLineDash([markLineOption.dashLength, markLineOption.dashLength])
    }
    context.setStrokeStyle(item.lineColor)
    context.setLineWidth(1 * opts.pix)
    context.beginPath()
    context.moveTo(startX, item.y)
    context.lineTo(endX, item.y)
    context.stroke()
    context.setLineDash([])
    if (item.showLabel) {
      let fontSize = item.labelFontSize * opts.pix
      let labelText = item.labelText ? item.labelText : item.value
      context.setFontSize(fontSize)
      let textWidth = measureText(labelText, fontSize, context)
      let bgWidth = textWidth + item.labelPadding * opts.pix * 2
      let bgStartX = item.labelAlign == 'left' ? opts.area[3] - bgWidth : opts.width - opts.area[1]
      bgStartX += item.labelOffsetX
      let bgStartY = item.y - 0.5 * fontSize - item.labelPadding * opts.pix
      bgStartY += item.labelOffsetY
      let textX = bgStartX + item.labelPadding * opts.pix
      let textY = item.y
      context.setFillStyle(hexToRgb(item.labelBgColor, item.labelBgOpacity))
      context.setStrokeStyle(item.labelBgColor)
      context.setLineWidth(1 * opts.pix)
      context.beginPath()
      context.rect(bgStartX, bgStartY, bgWidth, fontSize + 2 * item.labelPadding * opts.pix)
      context.closePath()
      context.stroke()
      context.fill()
      context.setFontSize(fontSize)
      context.setTextAlign('left')
      context.setFillStyle(item.labelFontColor)
      context.fillText(
        String(labelText),
        textX,
        bgStartY + fontSize + (item.labelPadding * opts.pix) / 2
      )
      context.stroke()
      context.setTextAlign('left')
    }
  }
}

function drawToolTipHorizentalLine(opts, config, context, eachSpacing, xAxisPoints) {
  var toolTipOption = assign(
    {},
    {
      gridType: 'solid',
      dashLength: 4
    },
    opts.extra.tooltip
  )
  var startX = opts.area[3]
  var endX = opts.width - opts.area[1]
  if (toolTipOption.gridType == 'dash') {
    context.setLineDash([toolTipOption.dashLength, toolTipOption.dashLength])
  }
  context.setStrokeStyle(toolTipOption.gridColor || '#cccccc')
  context.setLineWidth(1 * opts.pix)
  context.beginPath()
  context.moveTo(startX, opts.tooltip.offset.y)
  context.lineTo(endX, opts.tooltip.offset.y)
  context.stroke()
  context.setLineDash([])
  if (toolTipOption.yAxisLabel) {
    let boxPadding = toolTipOption.boxPadding * opts.pix
    let labelText = calTooltipYAxisData(
      opts.tooltip.offset.y,
      opts.series,
      opts,
      config,
      eachSpacing
    )
    let widthArr = opts.chartData.yAxisData.yAxisWidth
    let tStartLeft = opts.area[3]
    let tStartRight = opts.width - opts.area[1]
    for (let i = 0; i < labelText.length; i++) {
      context.setFontSize(toolTipOption.fontSize * opts.pix)
      let textWidth = measureText(labelText[i], toolTipOption.fontSize * opts.pix, context)
      let bgStartX, bgEndX, bgWidth
      if (widthArr[i].position == 'left') {
        bgStartX = tStartLeft - (textWidth + boxPadding * 2) - 2 * opts.pix
        bgEndX = Math.max(bgStartX, bgStartX + textWidth + boxPadding * 2)
      } else {
        bgStartX = tStartRight + 2 * opts.pix
        bgEndX = Math.max(bgStartX + widthArr[i].width, bgStartX + textWidth + boxPadding * 2)
      }
      bgWidth = bgEndX - bgStartX
      let textX = bgStartX + (bgWidth - textWidth) / 2
      let textY = opts.tooltip.offset.y
      context.beginPath()
      context.setFillStyle(
        hexToRgb(
          toolTipOption.labelBgColor || config.toolTipBackground,
          toolTipOption.labelBgOpacity || config.toolTipOpacity
        )
      )
      context.setStrokeStyle(toolTipOption.labelBgColor || config.toolTipBackground)
      context.setLineWidth(1 * opts.pix)
      context.rect(
        bgStartX,
        textY - 0.5 * config.fontSize - boxPadding,
        bgWidth,
        config.fontSize + 2 * boxPadding
      )
      context.closePath()
      context.stroke()
      context.fill()
      context.beginPath()
      context.setFontSize(config.fontSize)
      context.setFillStyle(toolTipOption.labelFontColor || opts.fontColor)
      context.fillText(labelText[i], textX, textY + 0.5 * config.fontSize)
      context.closePath()
      context.stroke()
      if (widthArr[i].position == 'left') {
        tStartLeft -= widthArr[i].width + opts.yAxis.padding * opts.pix
      } else {
        tStartRight += widthArr[i].width + opts.yAxis.padding * opts.pix
      }
    }
  }
}

function drawToolTipSplitArea(offsetX, opts, config, context, eachSpacing) {
  var toolTipOption = assign(
    {},
    {
      activeBgColor: '#000000',
      activeBgOpacity: 0.08,
      activeWidth: eachSpacing
    },
    opts.extra.column
  )
  toolTipOption.activeWidth =
    toolTipOption.activeWidth > eachSpacing ? eachSpacing : toolTipOption.activeWidth
  var startY = opts.area[0]
  var endY = opts.height - opts.area[2]
  context.beginPath()
  context.setFillStyle(hexToRgb(toolTipOption.activeBgColor, toolTipOption.activeBgOpacity))
  context.rect(
    offsetX - toolTipOption.activeWidth / 2,
    startY,
    toolTipOption.activeWidth,
    endY - startY
  )
  context.closePath()
  context.fill()
  context.setFillStyle('#FFFFFF')
}

function drawBarToolTipSplitArea(offsetX, opts, config, context, eachSpacing) {
  var toolTipOption = assign(
    {},
    {
      activeBgColor: '#000000',
      activeBgOpacity: 0.08
    },
    opts.extra.bar
  )
  var startX = opts.area[3]
  var endX = opts.width - opts.area[1]
  context.beginPath()
  context.setFillStyle(hexToRgb(toolTipOption.activeBgColor, toolTipOption.activeBgOpacity))
  context.rect(startX, offsetX - eachSpacing / 2, endX - startX, eachSpacing)
  context.closePath()
  context.fill()
  context.setFillStyle('#FFFFFF')
}

function drawToolTip(textList, offset, opts, config, context, eachSpacing, xAxisPoints) {
  var toolTipOption = assign(
    {},
    {
      showBox: true,
      showArrow: true,
      showCategory: false,
      bgColor: '#000000',
      bgOpacity: 0.7,
      borderColor: '#000000',
      borderWidth: 0,
      borderRadius: 0,
      borderOpacity: 0.7,
      boxPadding: 3,
      fontColor: '#FFFFFF',
      fontSize: 13,
      lineHeight: 20,
      legendShow: true,
      legendShape: 'auto',
      splitLine: true
    },
    opts.extra.tooltip
  )
  if (toolTipOption.showCategory == true && opts.categories) {
    textList.unshift({ text: opts.categories[opts.tooltip.index], color: null })
  }
  var fontSize = toolTipOption.fontSize * opts.pix
  var lineHeight = toolTipOption.lineHeight * opts.pix
  var boxPadding = toolTipOption.boxPadding * opts.pix
  var legendWidth = fontSize
  var legendMarginRight = 5 * opts.pix
  if (toolTipOption.legendShow == false) {
    legendWidth = 0
    legendMarginRight = 0
  }
  var arrowWidth = toolTipOption.showArrow ? 8 * opts.pix : 0
  var isOverRightBorder = false
  if (
    opts.type == 'line' ||
    opts.type == 'mount' ||
    opts.type == 'area' ||
    opts.type == 'candle' ||
    opts.type == 'mix'
  ) {
    if (toolTipOption.splitLine == true) {
      drawToolTipSplitLine(opts.tooltip.offset.x, opts, config, context)
    }
  }
  offset = assign(
    {
      x: 0,
      y: 0
    },
    offset
  )
  offset.y -= 8 * opts.pix
  var textWidth = textList.map(function (item) {
    return measureText(item.text, fontSize, context)
  })
  var toolTipWidth =
    legendWidth + legendMarginRight + 4 * boxPadding + Math.max.apply(null, textWidth)
  var toolTipHeight = 2 * boxPadding + textList.length * lineHeight
  if (toolTipOption.showBox == false) {
    return
  }
  // if beyond the right border
  if (offset.x - Math.abs(opts._scrollDistance_ || 0) + arrowWidth + toolTipWidth > opts.width) {
    isOverRightBorder = true
  }
  if (toolTipHeight + offset.y > opts.height) {
    offset.y = opts.height - toolTipHeight
  }
  // draw background rect
  context.beginPath()
  context.setFillStyle(hexToRgb(toolTipOption.bgColor, toolTipOption.bgOpacity))
  context.setLineWidth(toolTipOption.borderWidth * opts.pix)
  context.setStrokeStyle(hexToRgb(toolTipOption.borderColor, toolTipOption.borderOpacity))
  var radius = toolTipOption.borderRadius
  if (isOverRightBorder) {
    // 增加左侧仍然超出的判断
    if (toolTipWidth + arrowWidth > opts.width) {
      offset.x =
        opts.width + Math.abs(opts._scrollDistance_ || 0) + arrowWidth + (toolTipWidth - opts.width)
    }
    if (toolTipWidth > offset.x) {
      offset.x =
        opts.width + Math.abs(opts._scrollDistance_ || 0) + arrowWidth + (toolTipWidth - opts.width)
    }
    if (toolTipOption.showArrow) {
      context.moveTo(offset.x, offset.y + 10 * opts.pix)
      context.lineTo(offset.x - arrowWidth, offset.y + 10 * opts.pix + 5 * opts.pix)
    }
    context.arc(
      offset.x - arrowWidth - radius,
      offset.y + toolTipHeight - radius,
      radius,
      0,
      Math.PI / 2,
      false
    )
    context.arc(
      offset.x - arrowWidth - Math.round(toolTipWidth) + radius,
      offset.y + toolTipHeight - radius,
      radius,
      Math.PI / 2,
      Math.PI,
      false
    )
    context.arc(
      offset.x - arrowWidth - Math.round(toolTipWidth) + radius,
      offset.y + radius,
      radius,
      -Math.PI,
      -Math.PI / 2,
      false
    )
    context.arc(offset.x - arrowWidth - radius, offset.y + radius, radius, -Math.PI / 2, 0, false)
    if (toolTipOption.showArrow) {
      context.lineTo(offset.x - arrowWidth, offset.y + 10 * opts.pix - 5 * opts.pix)
      context.lineTo(offset.x, offset.y + 10 * opts.pix)
    }
  } else {
    if (toolTipOption.showArrow) {
      context.moveTo(offset.x, offset.y + 10 * opts.pix)
      context.lineTo(offset.x + arrowWidth, offset.y + 10 * opts.pix - 5 * opts.pix)
    }
    context.arc(
      offset.x + arrowWidth + radius,
      offset.y + radius,
      radius,
      -Math.PI,
      -Math.PI / 2,
      false
    )
    context.arc(
      offset.x + arrowWidth + Math.round(toolTipWidth) - radius,
      offset.y + radius,
      radius,
      -Math.PI / 2,
      0,
      false
    )
    context.arc(
      offset.x + arrowWidth + Math.round(toolTipWidth) - radius,
      offset.y + toolTipHeight - radius,
      radius,
      0,
      Math.PI / 2,
      false
    )
    context.arc(
      offset.x + arrowWidth + radius,
      offset.y + toolTipHeight - radius,
      radius,
      Math.PI / 2,
      Math.PI,
      false
    )
    if (toolTipOption.showArrow) {
      context.lineTo(offset.x + arrowWidth, offset.y + 10 * opts.pix + 5 * opts.pix)
      context.lineTo(offset.x, offset.y + 10 * opts.pix)
    }
  }
  context.closePath()
  context.fill()
  if (toolTipOption.borderWidth > 0) {
    context.stroke()
  }
  // draw legend
  if (toolTipOption.legendShow) {
    textList.forEach(function (item, index) {
      if (item.color !== null) {
        context.beginPath()
        context.setFillStyle(item.color)
        var startX = offset.x + arrowWidth + 2 * boxPadding
        var startY = offset.y + (lineHeight - fontSize) / 2 + lineHeight * index + boxPadding + 1
        if (isOverRightBorder) {
          startX = offset.x - toolTipWidth - arrowWidth + 2 * boxPadding
        }
        switch (item.legendShape) {
          case 'line':
            context.moveTo(startX, startY + 0.5 * legendWidth - 2 * opts.pix)
            context.fillRect(
              startX,
              startY + 0.5 * legendWidth - 2 * opts.pix,
              legendWidth,
              4 * opts.pix
            )
            break
          case 'triangle':
            context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth - 5 * opts.pix)
            context.lineTo(startX + 2.5 * opts.pix, startY + 0.5 * legendWidth + 5 * opts.pix)
            context.lineTo(startX + 12.5 * opts.pix, startY + 0.5 * legendWidth + 5 * opts.pix)
            context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth - 5 * opts.pix)
            break
          case 'diamond':
            context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth - 5 * opts.pix)
            context.lineTo(startX + 2.5 * opts.pix, startY + 0.5 * legendWidth)
            context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth + 5 * opts.pix)
            context.lineTo(startX + 12.5 * opts.pix, startY + 0.5 * legendWidth)
            context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth - 5 * opts.pix)
            break
          case 'circle':
            context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * legendWidth)
            context.arc(
              startX + 7.5 * opts.pix,
              startY + 0.5 * legendWidth,
              5 * opts.pix,
              0,
              2 * Math.PI
            )
            break
          case 'rect':
            context.moveTo(startX, startY + 0.5 * legendWidth - 5 * opts.pix)
            context.fillRect(
              startX,
              startY + 0.5 * legendWidth - 5 * opts.pix,
              15 * opts.pix,
              10 * opts.pix
            )
            break
          case 'square':
            context.moveTo(startX + 2 * opts.pix, startY + 0.5 * legendWidth - 5 * opts.pix)
            context.fillRect(
              startX + 2 * opts.pix,
              startY + 0.5 * legendWidth - 5 * opts.pix,
              10 * opts.pix,
              10 * opts.pix
            )
            break
          default:
            context.moveTo(startX, startY + 0.5 * legendWidth - 5 * opts.pix)
            context.fillRect(
              startX,
              startY + 0.5 * legendWidth - 5 * opts.pix,
              15 * opts.pix,
              10 * opts.pix
            )
        }
        context.closePath()
        context.fill()
      }
    })
  }

  // draw text list
  textList.forEach(function (item, index) {
    var startX = offset.x + arrowWidth + 2 * boxPadding + legendWidth + legendMarginRight
    if (isOverRightBorder) {
      startX =
        offset.x - toolTipWidth - arrowWidth + 2 * boxPadding + legendWidth + legendMarginRight
    }
    var startY =
      offset.y + lineHeight * index + (lineHeight - fontSize) / 2 - 1 + boxPadding + fontSize
    context.beginPath()
    context.setFontSize(fontSize)
    context.setTextBaseline('normal')
    context.setFillStyle(toolTipOption.fontColor)
    context.fillText(item.text, startX, startY)
    context.closePath()
    context.stroke()
  })
}

function drawColumnDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  let columnOption = assign(
    {},
    {
      type: 'group',
      width: eachSpacing / 2,
      meterBorder: 4,
      meterFillColor: '#FFFFFF',
      barBorderCircle: false,
      barBorderRadius: [],
      seriesGap: 2,
      linearType: 'none',
      linearOpacity: 1,
      customColor: [],
      colorStop: 0,
      labelPosition: 'outside'
    },
    opts.extra.column
  )
  let calPoints = []
  context.save()
  let leftNum = -2
  let rightNum = xAxisPoints.length + 2
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
    rightNum = leftNum + opts.xAxis.itemCount + 4
  }
  if (opts.tooltip && opts.tooltip.textList && opts.tooltip.textList.length && process === 1) {
    drawToolTipSplitArea(opts.tooltip.offset.x, opts, config, context, eachSpacing)
  }
  columnOption.customColor = fillCustomColor(
    columnOption.linearType,
    columnOption.customColor,
    series,
    config
  )
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()

    // 计算0轴坐标
    let spacingValid = opts.height - opts.area[0] - opts.area[2]
    let zeroHeight = (spacingValid * (0 - minRange)) / (maxRange - minRange)
    let zeroPoints = opts.height - Math.round(zeroHeight) - opts.area[2]
    eachSeries.zeroPoints = zeroPoints
    var data = eachSeries.data
    switch (columnOption.type) {
      case 'group':
        var points = getColumnDataPoints(
          data,
          minRange,
          maxRange,
          xAxisPoints,
          eachSpacing,
          opts,
          config,
          zeroPoints,
          process
        )
        var tooltipPoints = getStackDataPoints(
          data,
          minRange,
          maxRange,
          xAxisPoints,
          eachSpacing,
          opts,
          config,
          seriesIndex,
          series,
          process
        )
        calPoints.push(tooltipPoints)
        points = fixColumeData(points, eachSpacing, series.length, seriesIndex, config, opts)
        for (let i = 0; i < points.length; i++) {
          let item = points[i]
          //fix issues/I27B1N yyoinge & Joeshu
          if (item !== null && i > leftNum && i < rightNum) {
            var startX = item.x - item.width / 2
            var height = opts.height - item.y - opts.area[2]
            context.beginPath()
            var fillColor = item.color || eachSeries.color
            var strokeColor = item.color || eachSeries.color
            if (columnOption.linearType !== 'none') {
              var grd = context.createLinearGradient(startX, item.y, startX, zeroPoints)
              //透明渐变
              if (columnOption.linearType == 'opacity') {
                grd.addColorStop(0, hexToRgb(fillColor, columnOption.linearOpacity))
                grd.addColorStop(1, hexToRgb(fillColor, 1))
              } else {
                grd.addColorStop(
                  0,
                  hexToRgb(
                    columnOption.customColor[eachSeries.linearIndex],
                    columnOption.linearOpacity
                  )
                )
                grd.addColorStop(
                  columnOption.colorStop,
                  hexToRgb(
                    columnOption.customColor[eachSeries.linearIndex],
                    columnOption.linearOpacity
                  )
                )
                grd.addColorStop(1, hexToRgb(fillColor, 1))
              }
              fillColor = grd
            }
            // 圆角边框
            if (
              (columnOption.barBorderRadius && columnOption.barBorderRadius.length === 4) ||
              columnOption.barBorderCircle === true
            ) {
              const left = startX
              const top = item.y > zeroPoints ? zeroPoints : item.y
              const width = item.width
              const height = Math.abs(zeroPoints - item.y)
              if (columnOption.barBorderCircle) {
                columnOption.barBorderRadius = [width / 2, width / 2, 0, 0]
              }
              if (item.y > zeroPoints) {
                columnOption.barBorderRadius = [0, 0, width / 2, width / 2]
              }
              let [r0, r1, r2, r3] = columnOption.barBorderRadius
              let minRadius = Math.min(width / 2, height / 2)
              r0 = r0 > minRadius ? minRadius : r0
              r1 = r1 > minRadius ? minRadius : r1
              r2 = r2 > minRadius ? minRadius : r2
              r3 = r3 > minRadius ? minRadius : r3
              r0 = r0 < 0 ? 0 : r0
              r1 = r1 < 0 ? 0 : r1
              r2 = r2 < 0 ? 0 : r2
              r3 = r3 < 0 ? 0 : r3
              context.arc(left + r0, top + r0, r0, -Math.PI, -Math.PI / 2)
              context.arc(left + width - r1, top + r1, r1, -Math.PI / 2, 0)
              context.arc(left + width - r2, top + height - r2, r2, 0, Math.PI / 2)
              context.arc(left + r3, top + height - r3, r3, Math.PI / 2, Math.PI)
            } else {
              context.moveTo(startX, item.y)
              context.lineTo(startX + item.width, item.y)
              context.lineTo(startX + item.width, zeroPoints)
              context.lineTo(startX, zeroPoints)
              context.lineTo(startX, item.y)
              context.setLineWidth(1)
              context.setStrokeStyle(strokeColor)
            }
            context.setFillStyle(fillColor)
            context.closePath()
            //context.stroke();
            context.fill()
          }
        }
        break
      case 'stack':
        // 绘制堆叠数据图
        var points = getStackDataPoints(
          data,
          minRange,
          maxRange,
          xAxisPoints,
          eachSpacing,
          opts,
          config,
          seriesIndex,
          series,
          process
        )
        calPoints.push(points)
        points = fixColumeStackData(
          points,
          eachSpacing,
          series.length,
          seriesIndex,
          config,
          opts,
          series
        )
        for (let i = 0; i < points.length; i++) {
          let item = points[i]
          if (item !== null && i > leftNum && i < rightNum) {
            context.beginPath()
            var fillColor = item.color || eachSeries.color
            var startX = item.x - item.width / 2 + 1
            var height = opts.height - item.y - opts.area[2]
            var height0 = opts.height - item.y0 - opts.area[2]
            if (seriesIndex > 0) {
              height -= height0
            }
            context.setFillStyle(fillColor)
            context.moveTo(startX, item.y)
            context.fillRect(startX, item.y, item.width, height)
            context.closePath()
            context.fill()
          }
        }
        break
      case 'meter':
        // 绘制温度计数据图
        var points = getDataPoints(
          data,
          minRange,
          maxRange,
          xAxisPoints,
          eachSpacing,
          opts,
          config,
          process
        )
        calPoints.push(points)
        points = fixColumeMeterData(
          points,
          eachSpacing,
          series.length,
          seriesIndex,
          config,
          opts,
          columnOption.meterBorder
        )
        for (let i = 0; i < points.length; i++) {
          let item = points[i]
          if (item !== null && i > leftNum && i < rightNum) {
            //画背景颜色
            context.beginPath()
            if (seriesIndex == 0 && columnOption.meterBorder > 0) {
              context.setStrokeStyle(eachSeries.color)
              context.setLineWidth(columnOption.meterBorder * opts.pix)
            }
            if (seriesIndex == 0) {
              context.setFillStyle(columnOption.meterFillColor)
            } else {
              context.setFillStyle(item.color || eachSeries.color)
            }
            var startX = item.x - item.width / 2
            var height = opts.height - item.y - opts.area[2]
            if (
              (columnOption.barBorderRadius && columnOption.barBorderRadius.length === 4) ||
              columnOption.barBorderCircle === true
            ) {
              const left = startX
              const top = item.y
              const width = item.width
              const height = zeroPoints - item.y
              if (columnOption.barBorderCircle) {
                columnOption.barBorderRadius = [width / 2, width / 2, 0, 0]
              }
              let [r0, r1, r2, r3] = columnOption.barBorderRadius
              let minRadius = Math.min(width / 2, height / 2)
              r0 = r0 > minRadius ? minRadius : r0
              r1 = r1 > minRadius ? minRadius : r1
              r2 = r2 > minRadius ? minRadius : r2
              r3 = r3 > minRadius ? minRadius : r3
              r0 = r0 < 0 ? 0 : r0
              r1 = r1 < 0 ? 0 : r1
              r2 = r2 < 0 ? 0 : r2
              r3 = r3 < 0 ? 0 : r3
              context.arc(left + r0, top + r0, r0, -Math.PI, -Math.PI / 2)
              context.arc(left + width - r1, top + r1, r1, -Math.PI / 2, 0)
              context.arc(left + width - r2, top + height - r2, r2, 0, Math.PI / 2)
              context.arc(left + r3, top + height - r3, r3, Math.PI / 2, Math.PI)
              context.fill()
            } else {
              context.moveTo(startX, item.y)
              context.lineTo(startX + item.width, item.y)
              context.lineTo(startX + item.width, zeroPoints)
              context.lineTo(startX, zeroPoints)
              context.lineTo(startX, item.y)
              context.fill()
            }
            if (seriesIndex == 0 && columnOption.meterBorder > 0) {
              context.closePath()
              context.stroke()
            }
          }
        }
        break
    }
  })

  if (opts.dataLabel !== false && process === 1) {
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      switch (columnOption.type) {
        case 'group':
          var points = getColumnDataPoints(
            data,
            minRange,
            maxRange,
            xAxisPoints,
            eachSpacing,
            opts,
            config,
            process
          )
          points = fixColumeData(points, eachSpacing, series.length, seriesIndex, config, opts)
          drawColumePointText(points, eachSeries, config, context, opts)
          break
        case 'stack':
          var points = getStackDataPoints(
            data,
            minRange,
            maxRange,
            xAxisPoints,
            eachSpacing,
            opts,
            config,
            seriesIndex,
            series,
            process
          )
          drawColumePointText(points, eachSeries, config, context, opts)
          break
        case 'meter':
          var points = getDataPoints(
            data,
            minRange,
            maxRange,
            xAxisPoints,
            eachSpacing,
            opts,
            config,
            process
          )
          drawColumePointText(points, eachSeries, config, context, opts)
          break
      }
    })
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawMountDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  let mountOption = assign(
    {},
    {
      type: 'mount',
      widthRatio: 1,
      borderWidth: 1,
      barBorderCircle: false,
      barBorderRadius: [],
      linearType: 'none',
      linearOpacity: 1,
      customColor: [],
      colorStop: 0
    },
    opts.extra.mount
  )
  mountOption.widthRatio = mountOption.widthRatio <= 0 ? 0 : mountOption.widthRatio
  mountOption.widthRatio = mountOption.widthRatio >= 2 ? 2 : mountOption.widthRatio
  let calPoints = []
  context.save()
  let leftNum = -2
  let rightNum = xAxisPoints.length + 2
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
    rightNum = leftNum + opts.xAxis.itemCount + 4
  }
  mountOption.customColor = fillCustomColor(
    mountOption.linearType,
    mountOption.customColor,
    series,
    config
  )
  let ranges, minRange, maxRange
  ranges = [].concat(opts.chartData.yAxisData.ranges[0])
  minRange = ranges.pop()
  maxRange = ranges.shift()

  // 计算0轴坐标
  let spacingValid = opts.height - opts.area[0] - opts.area[2]
  let zeroHeight = (spacingValid * (0 - minRange)) / (maxRange - minRange)
  let zeroPoints = opts.height - Math.round(zeroHeight) - opts.area[2]

  var points = getMountDataPoints(
    series,
    minRange,
    maxRange,
    xAxisPoints,
    eachSpacing,
    opts,
    mountOption,
    zeroPoints,
    process
  )
  switch (mountOption.type) {
    case 'bar':
      for (let i = 0; i < points.length; i++) {
        let item = points[i]
        if (item !== null && i > leftNum && i < rightNum) {
          var startX = item.x - (eachSpacing * mountOption.widthRatio) / 2
          var height = opts.height - item.y - opts.area[2]
          context.beginPath()
          var fillColor = item.color || series[i].color
          var strokeColor = item.color || series[i].color
          if (mountOption.linearType !== 'none') {
            var grd = context.createLinearGradient(startX, item.y, startX, zeroPoints)
            //透明渐变
            if (mountOption.linearType == 'opacity') {
              grd.addColorStop(0, hexToRgb(fillColor, mountOption.linearOpacity))
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            } else {
              grd.addColorStop(
                0,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(
                mountOption.colorStop,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            }
            fillColor = grd
          }
          // 圆角边框
          if (
            (mountOption.barBorderRadius && mountOption.barBorderRadius.length === 4) ||
            mountOption.barBorderCircle === true
          ) {
            const left = startX
            const top = item.y > zeroPoints ? zeroPoints : item.y
            const width = item.width
            const height = Math.abs(zeroPoints - item.y)
            if (mountOption.barBorderCircle) {
              mountOption.barBorderRadius = [width / 2, width / 2, 0, 0]
            }
            if (item.y > zeroPoints) {
              mountOption.barBorderRadius = [0, 0, width / 2, width / 2]
            }
            let [r0, r1, r2, r3] = mountOption.barBorderRadius
            let minRadius = Math.min(width / 2, height / 2)
            r0 = r0 > minRadius ? minRadius : r0
            r1 = r1 > minRadius ? minRadius : r1
            r2 = r2 > minRadius ? minRadius : r2
            r3 = r3 > minRadius ? minRadius : r3
            r0 = r0 < 0 ? 0 : r0
            r1 = r1 < 0 ? 0 : r1
            r2 = r2 < 0 ? 0 : r2
            r3 = r3 < 0 ? 0 : r3
            context.arc(left + r0, top + r0, r0, -Math.PI, -Math.PI / 2)
            context.arc(left + width - r1, top + r1, r1, -Math.PI / 2, 0)
            context.arc(left + width - r2, top + height - r2, r2, 0, Math.PI / 2)
            context.arc(left + r3, top + height - r3, r3, Math.PI / 2, Math.PI)
          } else {
            context.moveTo(startX, item.y)
            context.lineTo(startX + item.width, item.y)
            context.lineTo(startX + item.width, zeroPoints)
            context.lineTo(startX, zeroPoints)
            context.lineTo(startX, item.y)
          }
          context.setStrokeStyle(strokeColor)
          context.setFillStyle(fillColor)
          if (mountOption.borderWidth > 0) {
            context.setLineWidth(mountOption.borderWidth * opts.pix)
            context.closePath()
            context.stroke()
          }
          context.fill()
        }
      }
      break
    case 'triangle':
      for (let i = 0; i < points.length; i++) {
        let item = points[i]
        if (item !== null && i > leftNum && i < rightNum) {
          var startX = item.x - (eachSpacing * mountOption.widthRatio) / 2
          var height = opts.height - item.y - opts.area[2]
          context.beginPath()
          var fillColor = item.color || series[i].color
          var strokeColor = item.color || series[i].color
          if (mountOption.linearType !== 'none') {
            var grd = context.createLinearGradient(startX, item.y, startX, zeroPoints)
            //透明渐变
            if (mountOption.linearType == 'opacity') {
              grd.addColorStop(0, hexToRgb(fillColor, mountOption.linearOpacity))
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            } else {
              grd.addColorStop(
                0,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(
                mountOption.colorStop,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            }
            fillColor = grd
          }
          context.moveTo(startX, zeroPoints)
          context.lineTo(item.x, item.y)
          context.lineTo(startX + item.width, zeroPoints)
          context.setStrokeStyle(strokeColor)
          context.setFillStyle(fillColor)
          if (mountOption.borderWidth > 0) {
            context.setLineWidth(mountOption.borderWidth * opts.pix)
            context.stroke()
          }
          context.fill()
        }
      }
      break
    case 'mount':
      for (let i = 0; i < points.length; i++) {
        let item = points[i]
        if (item !== null && i > leftNum && i < rightNum) {
          var startX = item.x - (eachSpacing * mountOption.widthRatio) / 2
          var height = opts.height - item.y - opts.area[2]
          context.beginPath()
          var fillColor = item.color || series[i].color
          var strokeColor = item.color || series[i].color
          if (mountOption.linearType !== 'none') {
            var grd = context.createLinearGradient(startX, item.y, startX, zeroPoints)
            //透明渐变
            if (mountOption.linearType == 'opacity') {
              grd.addColorStop(0, hexToRgb(fillColor, mountOption.linearOpacity))
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            } else {
              grd.addColorStop(
                0,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(
                mountOption.colorStop,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            }
            fillColor = grd
          }
          context.moveTo(startX, zeroPoints)
          context.bezierCurveTo(
            item.x - item.width / 4,
            zeroPoints,
            item.x - item.width / 4,
            item.y,
            item.x,
            item.y
          )
          context.bezierCurveTo(
            item.x + item.width / 4,
            item.y,
            item.x + item.width / 4,
            zeroPoints,
            startX + item.width,
            zeroPoints
          )
          context.setStrokeStyle(strokeColor)
          context.setFillStyle(fillColor)
          if (mountOption.borderWidth > 0) {
            context.setLineWidth(mountOption.borderWidth * opts.pix)
            context.stroke()
          }
          context.fill()
        }
      }
      break
    case 'sharp':
      for (let i = 0; i < points.length; i++) {
        let item = points[i]
        if (item !== null && i > leftNum && i < rightNum) {
          var startX = item.x - (eachSpacing * mountOption.widthRatio) / 2
          var height = opts.height - item.y - opts.area[2]
          context.beginPath()
          var fillColor = item.color || series[i].color
          var strokeColor = item.color || series[i].color
          if (mountOption.linearType !== 'none') {
            var grd = context.createLinearGradient(startX, item.y, startX, zeroPoints)
            //透明渐变
            if (mountOption.linearType == 'opacity') {
              grd.addColorStop(0, hexToRgb(fillColor, mountOption.linearOpacity))
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            } else {
              grd.addColorStop(
                0,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(
                mountOption.colorStop,
                hexToRgb(mountOption.customColor[series[i].linearIndex], mountOption.linearOpacity)
              )
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            }
            fillColor = grd
          }
          context.moveTo(startX, zeroPoints)
          context.quadraticCurveTo(item.x - 0, zeroPoints - height / 4, item.x, item.y)
          context.quadraticCurveTo(
            item.x + 0,
            zeroPoints - height / 4,
            startX + item.width,
            zeroPoints
          )
          context.setStrokeStyle(strokeColor)
          context.setFillStyle(fillColor)
          if (mountOption.borderWidth > 0) {
            context.setLineWidth(mountOption.borderWidth * opts.pix)
            context.stroke()
          }
          context.fill()
        }
      }
      break
  }

  if (opts.dataLabel !== false && process === 1) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[0])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    var points = getMountDataPoints(
      series,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      mountOption,
      zeroPoints,
      process
    )
    drawMountPointText(points, series, config, context, opts, zeroPoints)
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: points,
    eachSpacing: eachSpacing
  }
}

function drawBarDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let yAxisPoints = []
  let eachSpacing = (opts.height - opts.area[0] - opts.area[2]) / opts.categories.length
  for (let i = 0; i < opts.categories.length; i++) {
    yAxisPoints.push(opts.area[0] + eachSpacing / 2 + eachSpacing * i)
  }
  let columnOption = assign(
    {},
    {
      type: 'group',
      width: eachSpacing / 2,
      meterBorder: 4,
      meterFillColor: '#FFFFFF',
      barBorderCircle: false,
      barBorderRadius: [],
      seriesGap: 2,
      linearType: 'none',
      linearOpacity: 1,
      customColor: [],
      colorStop: 0
    },
    opts.extra.bar
  )
  let calPoints = []
  context.save()
  let leftNum = -2
  let rightNum = yAxisPoints.length + 2
  if (opts.tooltip && opts.tooltip.textList && opts.tooltip.textList.length && process === 1) {
    drawBarToolTipSplitArea(opts.tooltip.offset.y, opts, config, context, eachSpacing)
  }
  columnOption.customColor = fillCustomColor(
    columnOption.linearType,
    columnOption.customColor,
    series,
    config
  )
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.xAxisData.ranges)
    maxRange = ranges.pop()
    minRange = ranges.shift()
    var data = eachSeries.data
    switch (columnOption.type) {
      case 'group':
        var points = getBarDataPoints(
          data,
          minRange,
          maxRange,
          yAxisPoints,
          eachSpacing,
          opts,
          config,
          process
        )
        var tooltipPoints = getBarStackDataPoints(
          data,
          minRange,
          maxRange,
          yAxisPoints,
          eachSpacing,
          opts,
          config,
          seriesIndex,
          series,
          process
        )
        calPoints.push(tooltipPoints)
        points = fixBarData(points, eachSpacing, series.length, seriesIndex, config, opts)
        for (let i = 0; i < points.length; i++) {
          let item = points[i]
          //fix issues/I27B1N yyoinge & Joeshu
          if (item !== null && i > leftNum && i < rightNum) {
            //var startX = item.x - item.width / 2;
            var startX = opts.area[3]
            var startY = item.y - item.width / 2
            var height = item.height
            context.beginPath()
            var fillColor = item.color || eachSeries.color
            var strokeColor = item.color || eachSeries.color
            if (columnOption.linearType !== 'none') {
              var grd = context.createLinearGradient(startX, item.y, item.x, item.y)
              //透明渐变
              if (columnOption.linearType == 'opacity') {
                grd.addColorStop(0, hexToRgb(fillColor, columnOption.linearOpacity))
                grd.addColorStop(1, hexToRgb(fillColor, 1))
              } else {
                grd.addColorStop(
                  0,
                  hexToRgb(
                    columnOption.customColor[eachSeries.linearIndex],
                    columnOption.linearOpacity
                  )
                )
                grd.addColorStop(
                  columnOption.colorStop,
                  hexToRgb(
                    columnOption.customColor[eachSeries.linearIndex],
                    columnOption.linearOpacity
                  )
                )
                grd.addColorStop(1, hexToRgb(fillColor, 1))
              }
              fillColor = grd
            }
            // 圆角边框
            if (
              (columnOption.barBorderRadius && columnOption.barBorderRadius.length === 4) ||
              columnOption.barBorderCircle === true
            ) {
              const left = startX
              const width = item.width
              const top = item.y - item.width / 2
              const height = item.height
              if (columnOption.barBorderCircle) {
                columnOption.barBorderRadius = [width / 2, width / 2, 0, 0]
              }
              let [r0, r1, r2, r3] = columnOption.barBorderRadius
              let minRadius = Math.min(width / 2, height / 2)
              r0 = r0 > minRadius ? minRadius : r0
              r1 = r1 > minRadius ? minRadius : r1
              r2 = r2 > minRadius ? minRadius : r2
              r3 = r3 > minRadius ? minRadius : r3
              r0 = r0 < 0 ? 0 : r0
              r1 = r1 < 0 ? 0 : r1
              r2 = r2 < 0 ? 0 : r2
              r3 = r3 < 0 ? 0 : r3

              context.arc(left + r3, top + r3, r3, -Math.PI, -Math.PI / 2)
              context.arc(item.x - r0, top + r0, r0, -Math.PI / 2, 0)
              context.arc(item.x - r1, top + width - r1, r1, 0, Math.PI / 2)
              context.arc(left + r2, top + width - r2, r2, Math.PI / 2, Math.PI)
            } else {
              context.moveTo(startX, startY)
              context.lineTo(item.x, startY)
              context.lineTo(item.x, startY + item.width)
              context.lineTo(startX, startY + item.width)
              context.lineTo(startX, startY)
              context.setLineWidth(1)
              context.setStrokeStyle(strokeColor)
            }
            context.setFillStyle(fillColor)
            context.closePath()
            //context.stroke();
            context.fill()
          }
        }
        break
      case 'stack':
        // 绘制堆叠数据图
        var points = getBarStackDataPoints(
          data,
          minRange,
          maxRange,
          yAxisPoints,
          eachSpacing,
          opts,
          config,
          seriesIndex,
          series,
          process
        )
        calPoints.push(points)
        points = fixBarStackData(
          points,
          eachSpacing,
          series.length,
          seriesIndex,
          config,
          opts,
          series
        )
        for (let i = 0; i < points.length; i++) {
          let item = points[i]
          if (item !== null && i > leftNum && i < rightNum) {
            context.beginPath()
            var fillColor = item.color || eachSeries.color
            var startX = item.x0
            context.setFillStyle(fillColor)
            context.moveTo(startX, item.y - item.width / 2)
            context.fillRect(startX, item.y - item.width / 2, item.height, item.width)
            context.closePath()
            context.fill()
          }
        }
        break
    }
  })

  if (opts.dataLabel !== false && process === 1) {
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.xAxisData.ranges)
      maxRange = ranges.pop()
      minRange = ranges.shift()
      var data = eachSeries.data
      switch (columnOption.type) {
        case 'group':
          var points = getBarDataPoints(
            data,
            minRange,
            maxRange,
            yAxisPoints,
            eachSpacing,
            opts,
            config,
            process
          )
          points = fixBarData(points, eachSpacing, series.length, seriesIndex, config, opts)
          drawBarPointText(points, eachSeries, config, context, opts)
          break
        case 'stack':
          var points = getBarStackDataPoints(
            data,
            minRange,
            maxRange,
            yAxisPoints,
            eachSpacing,
            opts,
            config,
            seriesIndex,
            series,
            process
          )
          drawBarPointText(points, eachSeries, config, context, opts)
          break
      }
    })
  }
  return {
    yAxisPoints: yAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawCandleDataPoints(series, seriesMA, opts, config, context) {
  var process = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
  var candleOption = assign(
    {},
    {
      color: {},
      average: {}
    },
    opts.extra.candle
  )
  candleOption.color = assign(
    {},
    {
      upLine: '#f04864',
      upFill: '#f04864',
      downLine: '#2fc25b',
      downFill: '#2fc25b'
    },
    candleOption.color
  )
  candleOption.average = assign(
    {},
    {
      show: false,
      name: [],
      day: [],
      color: config.color
    },
    candleOption.average
  )
  opts.extra.candle = candleOption
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  let calPoints = []
  context.save()
  let leftNum = -2
  let rightNum = xAxisPoints.length + 2
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
    rightNum = leftNum + opts.xAxis.itemCount + 4
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  //画均线
  if (candleOption.average.show || seriesMA) {
    //Merge pull request !12 from 邱贵翔
    seriesMA.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      var splitPointList = splitPoints(points, eachSeries)
      for (let i = 0; i < splitPointList.length; i++) {
        let points = splitPointList[i]
        context.beginPath()
        context.setStrokeStyle(eachSeries.color)
        context.setLineWidth(1)
        if (points.length === 1) {
          context.moveTo(points[0].x, points[0].y)
          context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI)
        } else {
          context.moveTo(points[0].x, points[0].y)
          let startPoint = 0
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              var ctrlPoint = createCurveControlPoints(points, j - 1)
              context.bezierCurveTo(
                ctrlPoint.ctrA.x,
                ctrlPoint.ctrA.y,
                ctrlPoint.ctrB.x,
                ctrlPoint.ctrB.y,
                item.x,
                item.y
              )
            }
          }
          context.moveTo(points[0].x, points[0].y)
        }
        context.closePath()
        context.stroke()
      }
    })
  }
  //画K线
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    var data = eachSeries.data
    var points = getCandleDataPoints(
      data,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      config,
      process
    )
    calPoints.push(points)
    var splitPointList = splitPoints(points, eachSeries)
    for (let i = 0; i < splitPointList[0].length; i++) {
      if (i > leftNum && i < rightNum) {
        let item = splitPointList[0][i]
        context.beginPath()
        //如果上涨
        if (data[i][1] - data[i][0] > 0) {
          context.setStrokeStyle(candleOption.color.upLine)
          context.setFillStyle(candleOption.color.upFill)
          context.setLineWidth(1 * opts.pix)
          context.moveTo(item[3].x, item[3].y) //顶点
          context.lineTo(item[1].x, item[1].y) //收盘中间点
          context.lineTo(item[1].x - eachSpacing / 4, item[1].y) //收盘左侧点
          context.lineTo(item[0].x - eachSpacing / 4, item[0].y) //开盘左侧点
          context.lineTo(item[0].x, item[0].y) //开盘中间点
          context.lineTo(item[2].x, item[2].y) //底点
          context.lineTo(item[0].x, item[0].y) //开盘中间点
          context.lineTo(item[0].x + eachSpacing / 4, item[0].y) //开盘右侧点
          context.lineTo(item[1].x + eachSpacing / 4, item[1].y) //收盘右侧点
          context.lineTo(item[1].x, item[1].y) //收盘中间点
          context.moveTo(item[3].x, item[3].y) //顶点
        } else {
          context.setStrokeStyle(candleOption.color.downLine)
          context.setFillStyle(candleOption.color.downFill)
          context.setLineWidth(1 * opts.pix)
          context.moveTo(item[3].x, item[3].y) //顶点
          context.lineTo(item[0].x, item[0].y) //开盘中间点
          context.lineTo(item[0].x - eachSpacing / 4, item[0].y) //开盘左侧点
          context.lineTo(item[1].x - eachSpacing / 4, item[1].y) //收盘左侧点
          context.lineTo(item[1].x, item[1].y) //收盘中间点
          context.lineTo(item[2].x, item[2].y) //底点
          context.lineTo(item[1].x, item[1].y) //收盘中间点
          context.lineTo(item[1].x + eachSpacing / 4, item[1].y) //收盘右侧点
          context.lineTo(item[0].x + eachSpacing / 4, item[0].y) //开盘右侧点
          context.lineTo(item[0].x, item[0].y) //开盘中间点
          context.moveTo(item[3].x, item[3].y) //顶点
        }
        context.closePath()
        context.fill()
        context.stroke()
      }
    }
  })
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawAreaDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var areaOption = assign(
    {},
    {
      type: 'straight',
      opacity: 0.2,
      addLine: false,
      width: 2,
      gradient: false,
      activeType: 'none'
    },
    opts.extra.area
  )
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  let endY = opts.height - opts.area[2]
  let calPoints = []
  context.save()
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    let data = eachSeries.data
    let points = getDataPoints(
      data,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      config,
      process
    )
    calPoints.push(points)
    let splitPointList = splitPoints(points, eachSeries)
    for (let i = 0; i < splitPointList.length; i++) {
      let points = splitPointList[i]
      // 绘制区域数
      context.beginPath()
      context.setStrokeStyle(hexToRgb(eachSeries.color, areaOption.opacity))
      if (areaOption.gradient) {
        let gradient = context.createLinearGradient(0, opts.area[0], 0, opts.height - opts.area[2])
        gradient.addColorStop('0', hexToRgb(eachSeries.color, areaOption.opacity))
        gradient.addColorStop('1.0', hexToRgb('#FFFFFF', 0.1))
        context.setFillStyle(gradient)
      } else {
        context.setFillStyle(hexToRgb(eachSeries.color, areaOption.opacity))
      }
      context.setLineWidth(areaOption.width * opts.pix)
      if (points.length > 1) {
        let firstPoint = points[0]
        let lastPoint = points[points.length - 1]
        context.moveTo(firstPoint.x, firstPoint.y)
        let startPoint = 0
        if (areaOption.type === 'curve') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              let ctrlPoint = createCurveControlPoints(points, j - 1)
              context.bezierCurveTo(
                ctrlPoint.ctrA.x,
                ctrlPoint.ctrA.y,
                ctrlPoint.ctrB.x,
                ctrlPoint.ctrB.y,
                item.x,
                item.y
              )
            }
          }
        }
        if (areaOption.type === 'straight') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              context.lineTo(item.x, item.y)
            }
          }
        }
        if (areaOption.type === 'step') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              context.lineTo(item.x, points[j - 1].y)
              context.lineTo(item.x, item.y)
            }
          }
        }
        context.lineTo(lastPoint.x, endY)
        context.lineTo(firstPoint.x, endY)
        context.lineTo(firstPoint.x, firstPoint.y)
      } else {
        let item = points[0]
        context.moveTo(item.x - eachSpacing / 2, item.y)
        // context.lineTo(item.x + eachSpacing / 2, item.y);
        // context.lineTo(item.x + eachSpacing / 2, endY);
        // context.lineTo(item.x - eachSpacing / 2, endY);
        // context.moveTo(item.x - eachSpacing / 2, item.y);
      }
      context.closePath()
      context.fill()
      //画连线
      if (areaOption.addLine) {
        if (eachSeries.lineType == 'dash') {
          let dashLength = eachSeries.dashLength ? eachSeries.dashLength : 8
          dashLength *= opts.pix
          context.setLineDash([dashLength, dashLength])
        }
        context.beginPath()
        context.setStrokeStyle(eachSeries.color)
        context.setLineWidth(areaOption.width * opts.pix)
        if (points.length === 1) {
          context.moveTo(points[0].x, points[0].y)
          // context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
        } else {
          context.moveTo(points[0].x, points[0].y)
          let startPoint = 0
          if (areaOption.type === 'curve') {
            for (let j = 0; j < points.length; j++) {
              let item = points[j]
              if (startPoint == 0 && item.x > leftSpace) {
                context.moveTo(item.x, item.y)
                startPoint = 1
              }
              if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
                let ctrlPoint = createCurveControlPoints(points, j - 1)
                context.bezierCurveTo(
                  ctrlPoint.ctrA.x,
                  ctrlPoint.ctrA.y,
                  ctrlPoint.ctrB.x,
                  ctrlPoint.ctrB.y,
                  item.x,
                  item.y
                )
              }
            }
          }
          if (areaOption.type === 'straight') {
            for (let j = 0; j < points.length; j++) {
              let item = points[j]
              if (startPoint == 0 && item.x > leftSpace) {
                context.moveTo(item.x, item.y)
                startPoint = 1
              }
              if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
                context.lineTo(item.x, item.y)
              }
            }
          }
          if (areaOption.type === 'step') {
            for (let j = 0; j < points.length; j++) {
              let item = points[j]
              if (startPoint == 0 && item.x > leftSpace) {
                context.moveTo(item.x, item.y)
                startPoint = 1
              }
              if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
                context.lineTo(item.x, points[j - 1].y)
                context.lineTo(item.x, item.y)
              }
            }
          }
          context.moveTo(points[0].x, points[0].y)
        }
        context.stroke()
        context.setLineDash([])
      }
    }
    //画点
    if (opts.dataPointShape !== false) {
      drawPointShape(points, eachSeries.color, eachSeries.pointShape, context, opts)
    }
    drawActivePoint(
      points,
      eachSeries.color,
      eachSeries.pointShape,
      context,
      opts,
      areaOption,
      seriesIndex
    )
  })

  if (opts.dataLabel !== false && process === 1) {
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      drawPointText(points, eachSeries, config, context, opts)
    })
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawScatterDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var scatterOption = assign(
    {},
    {
      type: 'circle'
    },
    opts.extra.scatter
  )
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  var calPoints = []
  context.save()
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    var data = eachSeries.data
    var points = getDataPoints(
      data,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      config,
      process
    )
    context.beginPath()
    context.setStrokeStyle(eachSeries.color)
    context.setFillStyle(eachSeries.color)
    context.setLineWidth(1 * opts.pix)
    var shape = eachSeries.pointShape
    if (shape === 'diamond') {
      points.forEach(function (item, index) {
        if (item !== null) {
          context.moveTo(item.x, item.y - 4.5)
          context.lineTo(item.x - 4.5, item.y)
          context.lineTo(item.x, item.y + 4.5)
          context.lineTo(item.x + 4.5, item.y)
          context.lineTo(item.x, item.y - 4.5)
        }
      })
    } else if (shape === 'circle') {
      points.forEach(function (item, index) {
        if (item !== null) {
          context.moveTo(item.x + 2.5 * opts.pix, item.y)
          context.arc(item.x, item.y, 3 * opts.pix, 0, 2 * Math.PI, false)
        }
      })
    } else if (shape === 'square') {
      points.forEach(function (item, index) {
        if (item !== null) {
          context.moveTo(item.x - 3.5, item.y - 3.5)
          context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
        }
      })
    } else if (shape === 'triangle') {
      points.forEach(function (item, index) {
        if (item !== null) {
          context.moveTo(item.x, item.y - 4.5)
          context.lineTo(item.x - 4.5, item.y + 4.5)
          context.lineTo(item.x + 4.5, item.y + 4.5)
          context.lineTo(item.x, item.y - 4.5)
        }
      })
    } else if (shape === 'triangle') {
      return
    }
    context.closePath()
    context.fill()
    context.stroke()
  })
  if (opts.dataLabel !== false && process === 1) {
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      drawPointText(points, eachSeries, config, context, opts)
    })
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawBubbleDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var bubbleOption = assign(
    {},
    {
      opacity: 1,
      border: 2
    },
    opts.extra.bubble
  )
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  var calPoints = []
  context.save()
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    var data = eachSeries.data
    var points = getDataPoints(
      data,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      config,
      process
    )
    context.beginPath()
    context.setStrokeStyle(eachSeries.color)
    context.setLineWidth(bubbleOption.border * opts.pix)
    context.setFillStyle(hexToRgb(eachSeries.color, bubbleOption.opacity))
    points.forEach(function (item, index) {
      context.moveTo(item.x + item.r, item.y)
      context.arc(item.x, item.y, item.r * opts.pix, 0, 2 * Math.PI, false)
    })
    context.closePath()
    context.fill()
    context.stroke()

    if (opts.dataLabel !== false && process === 1) {
      points.forEach(function (item, index) {
        context.beginPath()
        var fontSize = eachSeries.textSize * opts.pix || config.fontSize
        context.setFontSize(fontSize)
        context.setFillStyle(eachSeries.textColor || '#FFFFFF')
        context.setTextAlign('center')
        context.fillText(String(item.t), item.x, item.y + fontSize / 2)
        context.closePath()
        context.stroke()
        context.setTextAlign('left')
      })
    }
  })
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawLineDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var lineOption = assign(
    {},
    {
      type: 'straight',
      width: 2,
      activeType: 'none',
      linearType: 'none',
      onShadow: false,
      animation: 'vertical'
    },
    opts.extra.line
  )
  lineOption.width *= opts.pix
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  var calPoints = []
  context.save()
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  series.forEach(function (eachSeries, seriesIndex) {
    // 这段很神奇的代码用于解决ios16的setStrokeStyle失效的bug
    context.beginPath()
    context.setStrokeStyle(eachSeries.color)
    context.moveTo(-10000, -10000)
    context.lineTo(-10001, -10001)
    context.stroke()
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    var data = eachSeries.data
    var points = getLineDataPoints(
      data,
      minRange,
      maxRange,
      xAxisPoints,
      eachSpacing,
      opts,
      config,
      lineOption,
      process
    )
    calPoints.push(points)
    var splitPointList = splitPoints(points, eachSeries)
    if (eachSeries.lineType == 'dash') {
      let dashLength = eachSeries.dashLength ? eachSeries.dashLength : 8
      dashLength *= opts.pix
      context.setLineDash([dashLength, dashLength])
    }
    context.beginPath()
    var strokeColor = eachSeries.color
    if (
      lineOption.linearType !== 'none' &&
      eachSeries.linearColor &&
      eachSeries.linearColor.length > 0
    ) {
      var grd = context.createLinearGradient(
        opts.chartData.xAxisData.startX,
        opts.height / 2,
        opts.chartData.xAxisData.endX,
        opts.height / 2
      )
      for (var i = 0; i < eachSeries.linearColor.length; i++) {
        grd.addColorStop(eachSeries.linearColor[i][0], hexToRgb(eachSeries.linearColor[i][1], 1))
      }
      strokeColor = grd
    }
    context.setStrokeStyle(strokeColor)
    if (lineOption.onShadow == true && eachSeries.setShadow && eachSeries.setShadow.length > 0) {
      context.setShadow(
        eachSeries.setShadow[0],
        eachSeries.setShadow[1],
        eachSeries.setShadow[2],
        eachSeries.setShadow[3]
      )
    } else {
      context.setShadow(0, 0, 0, 'rgba(0,0,0,0)')
    }
    context.setLineWidth(lineOption.width)
    splitPointList.forEach(function (points, index) {
      if (points.length === 1) {
        context.moveTo(points[0].x, points[0].y)
        // context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
      } else {
        context.moveTo(points[0].x, points[0].y)
        let startPoint = 0
        if (lineOption.type === 'curve') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              var ctrlPoint = createCurveControlPoints(points, j - 1)
              context.bezierCurveTo(
                ctrlPoint.ctrA.x,
                ctrlPoint.ctrA.y,
                ctrlPoint.ctrB.x,
                ctrlPoint.ctrB.y,
                item.x,
                item.y
              )
            }
          }
        }
        if (lineOption.type === 'straight') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              context.lineTo(item.x, item.y)
            }
          }
        }
        if (lineOption.type === 'step') {
          for (let j = 0; j < points.length; j++) {
            let item = points[j]
            if (startPoint == 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              context.lineTo(item.x, points[j - 1].y)
              context.lineTo(item.x, item.y)
            }
          }
        }
        context.moveTo(points[0].x, points[0].y)
      }
    })
    context.stroke()
    context.setLineDash([])
    if (opts.dataPointShape !== false) {
      drawPointShape(points, eachSeries.color, eachSeries.pointShape, context, opts)
    }
    drawActivePoint(points, eachSeries.color, eachSeries.pointShape, context, opts, lineOption)
  })
  if (opts.dataLabel !== false && process === 1) {
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      drawPointText(points, eachSeries, config, context, opts)
    })
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawMixDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    eachSpacing = xAxisData.eachSpacing
  let columnOption = assign(
    {},
    {
      width: eachSpacing / 2,
      barBorderCircle: false,
      barBorderRadius: [],
      seriesGap: 2,
      linearType: 'none',
      linearOpacity: 1,
      customColor: [],
      colorStop: 0
    },
    opts.extra.mix.column
  )
  let areaOption = assign(
    {},
    {
      opacity: 0.2,
      gradient: false
    },
    opts.extra.mix.area
  )
  let lineOption = assign(
    {},
    {
      width: 2
    },
    opts.extra.mix.line
  )
  let endY = opts.height - opts.area[2]
  let calPoints = []
  var columnIndex = 0
  var columnLength = 0
  series.forEach(function (eachSeries, seriesIndex) {
    if (eachSeries.type == 'column') {
      columnLength += 1
    }
  })
  context.save()
  let leftNum = -2
  let rightNum = xAxisPoints.length + 2
  let leftSpace = 0
  let rightSpace = opts.width + eachSpacing
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
    leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
    rightNum = leftNum + opts.xAxis.itemCount + 4
    leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
    rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
  }
  columnOption.customColor = fillCustomColor(
    columnOption.linearType,
    columnOption.customColor,
    series,
    config
  )
  series.forEach(function (eachSeries, seriesIndex) {
    let ranges, minRange, maxRange
    ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
    minRange = ranges.pop()
    maxRange = ranges.shift()
    // 统一声明 points，确保后续 push 到 calPoints 不为 undefined
    var points
    if (eachSeries.type === 'area-range') {
      // 计算上边界
      eachSeries.upperPoints = getDataPoints(
        eachSeries.upperData, // 上边界数据
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )

      // 计算下边界
      eachSeries.lowerPoints = getDataPoints(
        eachSeries.lowerData, // 下边界数据
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      // 使用上边界点参与通用的 calPoints 逻辑，避免 tooltip 寻址时报错
      points = eachSeries.upperPoints
      eachSeries.points = eachSeries.upperPoints
    } else {
      // 原来的普通图形逻辑
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      eachSeries.points = points
    }
    calPoints.push(points)
    // 绘制柱状数据图
    if (eachSeries.type == 'column') {
      points = fixColumeData(points, eachSpacing, columnLength, columnIndex, config, opts)
      for (let i = 0; i < points.length; i++) {
        let item = points[i]
        if (item !== null && i > leftNum && i < rightNum) {
          var startX = item.x - item.width / 2
          var height = opts.height - item.y - opts.area[2]
          context.beginPath()
          var fillColor = item.color || eachSeries.color
          var strokeColor = item.color || eachSeries.color
          if (columnOption.linearType !== 'none') {
            var grd = context.createLinearGradient(
              startX,
              item.y,
              startX,
              opts.height - opts.area[2]
            )
            //透明渐变
            if (columnOption.linearType == 'opacity') {
              grd.addColorStop(0, hexToRgb(fillColor, columnOption.linearOpacity))
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            } else {
              grd.addColorStop(
                0,
                hexToRgb(
                  columnOption.customColor[eachSeries.linearIndex],
                  columnOption.linearOpacity
                )
              )
              grd.addColorStop(
                columnOption.colorStop,
                hexToRgb(
                  columnOption.customColor[eachSeries.linearIndex],
                  columnOption.linearOpacity
                )
              )
              grd.addColorStop(1, hexToRgb(fillColor, 1))
            }
            fillColor = grd
          }
          // 圆角边框
          if (
            (columnOption.barBorderRadius && columnOption.barBorderRadius.length === 4) ||
            columnOption.barBorderCircle
          ) {
            const left = startX
            const top = item.y
            const width = item.width
            const height = opts.height - opts.area[2] - item.y
            if (columnOption.barBorderCircle) {
              columnOption.barBorderRadius = [width / 2, width / 2, 0, 0]
            }
            let [r0, r1, r2, r3] = columnOption.barBorderRadius
            let minRadius = Math.min(width / 2, height / 2)
            r0 = r0 > minRadius ? minRadius : r0
            r1 = r1 > minRadius ? minRadius : r1
            r2 = r2 > minRadius ? minRadius : r2
            r3 = r3 > minRadius ? minRadius : r3
            r0 = r0 < 0 ? 0 : r0
            r1 = r1 < 0 ? 0 : r1
            r2 = r2 < 0 ? 0 : r2
            r3 = r3 < 0 ? 0 : r3
            context.arc(left + r0, top + r0, r0, -Math.PI, -Math.PI / 2)
            context.arc(left + width - r1, top + r1, r1, -Math.PI / 2, 0)
            context.arc(left + width - r2, top + height - r2, r2, 0, Math.PI / 2)
            context.arc(left + r3, top + height - r3, r3, Math.PI / 2, Math.PI)
          } else {
            context.moveTo(startX, item.y)
            context.lineTo(startX + item.width, item.y)
            context.lineTo(startX + item.width, opts.height - opts.area[2])
            context.lineTo(startX, opts.height - opts.area[2])
            context.lineTo(startX, item.y)
            context.setLineWidth(1)
            context.setStrokeStyle(strokeColor)
          }
          context.setFillStyle(fillColor)
          context.closePath()
          context.fill()
        }
      }
      columnIndex += 1
    }
    // //绘制区域图数据
    // if (eachSeries.type == 'area') {
    //   let splitPointList = splitPoints(points,eachSeries);
    //   for (let i = 0; i < splitPointList.length; i++) {
    //     let points = splitPointList[i];
    //     // 绘制区域数据
    //     context.beginPath();
    //     context.setStrokeStyle(eachSeries.color);
    //     context.setStrokeStyle(hexToRgb(eachSeries.color, areaOption.opacity));
    //     if (areaOption.gradient) {
    //       let gradient = context.createLinearGradient(0, opts.area[0], 0, opts.height - opts.area[2]);
    //       gradient.addColorStop('0', hexToRgb(eachSeries.color, areaOption.opacity));
    //       gradient.addColorStop('1.0', hexToRgb("#FFFFFF", 0.1));
    //       context.setFillStyle(gradient);
    //     } else {
    //       context.setFillStyle(hexToRgb(eachSeries.color, eachSeries.opacity? eachSeries.opacity : areaOption.opacity));
    //     }
    //     context.setLineWidth(2 * opts.pix);
    //     if (points.length > 1) {
    //       var firstPoint = points[0];
    //       let lastPoint = points[points.length - 1];
    //       context.moveTo(firstPoint.x, firstPoint.y);
    //       let startPoint = 0;
    //       if (eachSeries.style === 'curve') {
    //         for (let j = 0; j < points.length; j++) {
    //           let item = points[j];
    //           if (startPoint == 0 && item.x > leftSpace) {
    //             context.moveTo(item.x, item.y);
    //             startPoint = 1;
    //           }
    //           if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
    //             var ctrlPoint = createCurveControlPoints(points, j - 1);
    //             context.bezierCurveTo(ctrlPoint.ctrA.x, ctrlPoint.ctrA.y, ctrlPoint.ctrB.x, ctrlPoint.ctrB.y, item.x, item.y);
    //           }
    //         };
    //       } else {
    //         for (let j = 0; j < points.length; j++) {
    //           let item = points[j];
    //           if (startPoint == 0 && item.x > leftSpace) {
    //             context.moveTo(item.x, item.y);
    //             startPoint = 1;
    //           }
    //           if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
    //             context.lineTo(item.x, item.y);
    //           }
    //         };
    //       }
    //       context.lineTo(lastPoint.x, endY);
    //       context.lineTo(firstPoint.x, endY);
    //       context.lineTo(firstPoint.x, firstPoint.y);
    //     } else {
    //       let item = points[0];
    //       context.moveTo(item.x - eachSpacing / 2, item.y);
    //       // context.lineTo(item.x + eachSpacing / 2, item.y);
    //       // context.lineTo(item.x + eachSpacing / 2, endY);
    //       // context.lineTo(item.x - eachSpacing / 2, endY);
    //       // context.moveTo(item.x - eachSpacing / 2, item.y);
    //     }
    //     context.closePath();
    //     context.fill();
    //   }
    // }

    // 面积图（单线区域）和区间面积图（双线区域）
    if (eachSeries.type == 'area' || eachSeries.type == 'area-range') {
      // 数据点拆分（支持断点分段）
      let upperList, lowerList

      if (eachSeries.type == 'area') {
        // 原有单线面积图
        upperList = splitPoints(points, eachSeries)
      } else {
        // 新增上下区间
        upperList = splitPoints(eachSeries.upperPoints, eachSeries)
        lowerList = splitPoints(eachSeries.lowerPoints, eachSeries)
      }
      console.log(upperList, lowerList, '---')

      for (let i = 0; i < upperList.length; i++) {
        let upPoints = upperList[i]
        let downPoints = eachSeries.type == 'area-range' ? lowerList[i] : null

        context.beginPath()

        // 边框颜色（area 基本不显示 stroke，可忽略）
        context.setStrokeStyle(hexToRgb(eachSeries.color, areaOption.opacity))

        // 填充颜色 / 渐变
        if (areaOption.gradient) {
          let gradient = context.createLinearGradient(
            0,
            opts.area[0],
            0,
            opts.height - opts.area[2]
          )
          gradient.addColorStop(0, hexToRgb(eachSeries.color, areaOption.opacity))
          gradient.addColorStop(1, hexToRgb('#FFFFFF', 0.1))
          context.setFillStyle(gradient)
        } else {
          context.setFillStyle(
            hexToRgb(eachSeries.color, eachSeries.opacity ? eachSeries.opacity : areaOption.opacity)
          )
        }

        context.setLineWidth(2 * opts.pix)

        // ===== 绘制上边界线 =====
        let startPoint = 0
        if (eachSeries.style === 'curve') {
          for (let j = 0; j < upPoints.length; j++) {
            let item = upPoints[j]
            if (startPoint === 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              let ctrlPoint = createCurveControlPoints(upPoints, j - 1)
              context.bezierCurveTo(
                ctrlPoint.ctrA.x,
                ctrlPoint.ctrA.y,
                ctrlPoint.ctrB.x,
                ctrlPoint.ctrB.y,
                item.x,
                item.y
              )
            }
          }
        } else {
          for (let j = 0; j < upPoints.length; j++) {
            let item = upPoints[j]
            if (startPoint === 0 && item.x > leftSpace) {
              context.moveTo(item.x, item.y)
              startPoint = 1
            }
            if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
              context.lineTo(item.x, item.y)
            }
          }
        }

        // ===== 绘制下边界（area-range 用） =====
        if (eachSeries.type == 'area-range') {
          if (eachSeries.style === 'curve') {
            for (let j = downPoints.length - 1; j >= 0; j--) {
              let item = downPoints[j]
              if (j < downPoints.length - 1 && item.x > leftSpace && item.x < rightSpace) {
                let ctrlPoint = createCurveControlPoints(downPoints, j)
                context.bezierCurveTo(
                  ctrlPoint.ctrB.x,
                  ctrlPoint.ctrB.y,
                  ctrlPoint.ctrA.x,
                  ctrlPoint.ctrA.y,
                  item.x,
                  item.y
                )
              } else if (j === downPoints.length - 1) {
                context.lineTo(item.x, item.y)
              }
            }
          } else {
            for (let j = downPoints.length - 1; j >= 0; j--) {
              let item = downPoints[j]
              context.lineTo(item.x, item.y)
            }
          }
        } else {
          // 单线面积图闭合到基线
          let lastPoint = upPoints[upPoints.length - 1]
          let firstPoint = upPoints[0]
          context.lineTo(lastPoint.x, endY)
          context.lineTo(firstPoint.x, endY)
          context.lineTo(firstPoint.x, firstPoint.y)
        }

        context.closePath()
        context.fill()
      }
    }

    // 绘制折线数据图
    if (eachSeries.type == 'line') {
      var splitPointList = splitPoints(points, eachSeries)
      splitPointList.forEach(function (points, index) {
        if (eachSeries.lineType == 'dash') {
          let dashLength = eachSeries.dashLength ? eachSeries.dashLength : 8
          dashLength *= opts.pix
          context.setLineDash([dashLength, dashLength])
        }
        context.beginPath()
        context.setStrokeStyle(eachSeries.color)
        context.setLineWidth(lineOption.width * opts.pix)
        if (points.length === 1) {
          context.moveTo(points[0].x, points[0].y)
          // context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
        } else {
          context.moveTo(points[0].x, points[0].y)
          let startPoint = 0
          if (eachSeries.style == 'curve') {
            for (let j = 0; j < points.length; j++) {
              let item = points[j]
              if (startPoint == 0 && item.x > leftSpace) {
                context.moveTo(item.x, item.y)
                startPoint = 1
              }
              if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
                var ctrlPoint = createCurveControlPoints(points, j - 1)
                context.bezierCurveTo(
                  ctrlPoint.ctrA.x,
                  ctrlPoint.ctrA.y,
                  ctrlPoint.ctrB.x,
                  ctrlPoint.ctrB.y,
                  item.x,
                  item.y
                )
              }
            }
          } else {
            for (let j = 0; j < points.length; j++) {
              let item = points[j]
              if (startPoint == 0 && item.x > leftSpace) {
                context.moveTo(item.x, item.y)
                startPoint = 1
              }
              if (j > 0 && item.x > leftSpace && item.x < rightSpace) {
                context.lineTo(item.x, item.y)
              }
            }
          }
          context.moveTo(points[0].x, points[0].y)
        }
        context.stroke()
        context.setLineDash([])
      })
    }
    // 绘制点数据图
    if (eachSeries.type == 'point') {
      eachSeries.addPoint = true
    }
    if (eachSeries.addPoint == true && eachSeries.type !== 'column') {
      drawPointShape(points, eachSeries.color, eachSeries.pointShape, context, opts)
    }
  })
  if (opts.dataLabel !== false && process === 1) {
    var columnIndex = 0
    series.forEach(function (eachSeries, seriesIndex) {
      let ranges, minRange, maxRange
      ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
      minRange = ranges.pop()
      maxRange = ranges.shift()
      var data = eachSeries.data
      var points = getDataPoints(
        data,
        minRange,
        maxRange,
        xAxisPoints,
        eachSpacing,
        opts,
        config,
        process
      )
      if (eachSeries.type !== 'column') {
        drawPointText(points, eachSeries, config, context, opts)
      } else {
        points = fixColumeData(points, eachSpacing, columnLength, columnIndex, config, opts)
        drawPointText(points, eachSeries, config, context, opts)
        columnIndex += 1
      }
    })
  }
  context.restore()
  return {
    xAxisPoints: xAxisPoints,
    calPoints: calPoints,
    eachSpacing: eachSpacing
  }
}

function drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints) {
  var toolTipOption = opts.extra.tooltip || {}
  if (
    toolTipOption.horizentalLine &&
    opts.tooltip &&
    process === 1 &&
    (opts.type == 'line' ||
      opts.type == 'area' ||
      opts.type == 'column' ||
      opts.type == 'mount' ||
      opts.type == 'candle' ||
      opts.type == 'mix')
  ) {
    drawToolTipHorizentalLine(opts, config, context, eachSpacing, xAxisPoints)
  }
  context.save()
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0 && opts.enableScroll === true) {
    context.translate(opts._scrollDistance_, 0)
  }
  if (opts.tooltip && opts.tooltip.textList && opts.tooltip.textList.length && process === 1) {
    // console.log(opts.tooltip.textList, 'opts.tooltip.textList')
    const newTextList = opts.tooltip.textList.filter((item) => item.text)
    drawToolTip(newTextList, opts.tooltip.offset, opts, config, context, eachSpacing, xAxisPoints)
    // drawToolTip(opts.tooltip.textList, opts.tooltip.offset, opts, config, context, eachSpacing, xAxisPoints);
  }
  context.restore()
}

function drawXAxis(categories, opts, config, context) {
  let xAxisData = opts.chartData.xAxisData,
    xAxisPoints = xAxisData.xAxisPoints,
    startX = xAxisData.startX,
    endX = xAxisData.endX,
    eachSpacing = xAxisData.eachSpacing
  var boundaryGap = 'center'
  if (
    opts.type == 'bar' ||
    opts.type == 'line' ||
    opts.type == 'area' ||
    opts.type == 'scatter' ||
    opts.type == 'bubble'
  ) {
    boundaryGap = opts.xAxis.boundaryGap
  }
  var startY = opts.height - opts.area[2]
  var endY = opts.area[0]

  //绘制滚动条
  if (opts.enableScroll && opts.xAxis.scrollShow) {
    var scrollY = opts.height - opts.area[2] + config.xAxisHeight
    var scrollScreenWidth = endX - startX
    var scrollTotalWidth = eachSpacing * (xAxisPoints.length - 1)
    if (
      opts.type == 'mount' &&
      opts.extra &&
      opts.extra.mount &&
      opts.extra.mount.widthRatio &&
      opts.extra.mount.widthRatio > 1
    ) {
      if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
      scrollTotalWidth += (opts.extra.mount.widthRatio - 1) * eachSpacing
    }
    var scrollWidth = (scrollScreenWidth * scrollScreenWidth) / scrollTotalWidth
    var scrollLeft = 0
    if (opts._scrollDistance_) {
      scrollLeft = (-opts._scrollDistance_ * scrollScreenWidth) / scrollTotalWidth
    }
    context.beginPath()
    context.setLineCap('round')
    context.setLineWidth(6 * opts.pix)
    context.setStrokeStyle(opts.xAxis.scrollBackgroundColor || '#EFEBEF')
    context.moveTo(startX, scrollY)
    context.lineTo(endX, scrollY)
    context.stroke()
    context.closePath()
    context.beginPath()
    context.setLineCap('round')
    context.setLineWidth(6 * opts.pix)
    context.setStrokeStyle(opts.xAxis.scrollColor || '#A6A6A6')
    context.moveTo(startX + scrollLeft, scrollY)
    context.lineTo(startX + scrollLeft + scrollWidth, scrollY)
    context.stroke()
    context.closePath()
    context.setLineCap('butt')
  }
  context.save()
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0) {
    context.translate(opts._scrollDistance_, 0)
  }
  //绘制X轴刻度线
  if (opts.xAxis.calibration === true) {
    context.setStrokeStyle(opts.xAxis.gridColor || '#cccccc')
    context.setLineCap('butt')
    context.setLineWidth(1 * opts.pix)
    xAxisPoints.forEach(function (item, index) {
      if (index > 0) {
        context.beginPath()
        context.moveTo(item - eachSpacing / 2, startY)
        context.lineTo(item - eachSpacing / 2, startY + 3 * opts.pix)
        context.closePath()
        context.stroke()
      }
    })
  }
  //绘制X轴网格
  if (opts.xAxis.disableGrid !== true) {
    context.setStrokeStyle(opts.xAxis.gridColor || '#cccccc')
    context.setLineCap('butt')
    context.setLineWidth(1 * opts.pix)
    if (opts.xAxis.gridType == 'dash') {
      context.setLineDash([opts.xAxis.dashLength * opts.pix, opts.xAxis.dashLength * opts.pix])
    }
    opts.xAxis.gridEval = opts.xAxis.gridEval || 1
    xAxisPoints.forEach(function (item, index) {
      if (index % opts.xAxis.gridEval == 0) {
        context.beginPath()
        context.moveTo(item, startY)
        context.lineTo(item, endY)
        context.stroke()
      }
    })
    context.setLineDash([])
  }
  //绘制X轴文案
  if (opts.xAxis.disabled !== true) {
    // 对X轴列表做抽稀处理
    //默认全部显示X轴标签
    let maxXAxisListLength = categories.length
    //如果设置了X轴单屏数量
    if (opts.xAxis.labelCount) {
      //如果设置X轴密度
      if (opts.xAxis.itemCount) {
        maxXAxisListLength = Math.ceil(
          (categories.length / opts.xAxis.itemCount) * opts.xAxis.labelCount
        )
      } else {
        maxXAxisListLength = opts.xAxis.labelCount
      }
      maxXAxisListLength -= 1
    }

    let ratio = Math.ceil(categories.length / maxXAxisListLength)

    let newCategories = []
    let cgLength = categories.length
    for (let i = 0; i < cgLength; i++) {
      if (i % ratio !== 0) {
        newCategories.push('')
      } else {
        newCategories.push(categories[i])
      }
    }
    newCategories[cgLength - 1] = categories[cgLength - 1]
    var xAxisFontSize = opts.xAxis.fontSize * opts.pix || config.fontSize
    if (config._xAxisTextAngle_ === 0) {
      newCategories.forEach(function (item, index) {
        var xitem = opts.xAxis.formatter ? opts.xAxis.formatter(item, index, opts) : item
        var offset = -measureText(String(xitem), xAxisFontSize, context) / 2
        if (boundaryGap == 'center') {
          offset += eachSpacing / 2
        }
        var scrollHeight = 0
        if (opts.xAxis.scrollShow) {
          scrollHeight = 6 * opts.pix
        }
        // 如果在主视图区域内
        var _scrollDistance_ = opts._scrollDistance_ || 0
        var truePoints =
          boundaryGap == 'center' ? xAxisPoints[index] + eachSpacing / 2 : xAxisPoints[index]
        if (
          truePoints - Math.abs(_scrollDistance_) >= opts.area[3] - 1 &&
          truePoints - Math.abs(_scrollDistance_) <= opts.width - opts.area[1] + 1
        ) {
          context.beginPath()
          context.setFontSize(xAxisFontSize)
          context.setFillStyle(opts.xAxis.fontColor || opts.fontColor)
          context.fillText(
            String(xitem),
            xAxisPoints[index] + offset,
            startY +
              opts.xAxis.marginTop * opts.pix +
              ((opts.xAxis.lineHeight - opts.xAxis.fontSize) * opts.pix) / 2 +
              opts.xAxis.fontSize * opts.pix
          )
          context.closePath()
          context.stroke()
        }
      })
    } else {
      newCategories.forEach(function (item, index) {
        var xitem = opts.xAxis.formatter ? opts.xAxis.formatter(item) : item
        // 如果在主视图区域内
        var _scrollDistance_ = opts._scrollDistance_ || 0
        var truePoints =
          boundaryGap == 'center' ? xAxisPoints[index] + eachSpacing / 2 : xAxisPoints[index]
        if (
          truePoints - Math.abs(_scrollDistance_) >= opts.area[3] - 1 &&
          truePoints - Math.abs(_scrollDistance_) <= opts.width - opts.area[1] + 1
        ) {
          context.save()
          context.beginPath()
          context.setFontSize(xAxisFontSize)
          context.setFillStyle(opts.xAxis.fontColor || opts.fontColor)
          var textWidth = measureText(String(xitem), xAxisFontSize, context)
          var offsetX = xAxisPoints[index]
          if (boundaryGap == 'center') {
            offsetX = xAxisPoints[index] + eachSpacing / 2
          }
          var scrollHeight = 0
          if (opts.xAxis.scrollShow) {
            scrollHeight = 6 * opts.pix
          }
          var offsetY =
            startY +
            opts.xAxis.marginTop * opts.pix +
            xAxisFontSize -
            xAxisFontSize * Math.abs(Math.sin(config._xAxisTextAngle_))
          if (opts.xAxis.rotateAngle < 0) {
            offsetX -= xAxisFontSize / 2
            textWidth = 0
          } else {
            offsetX += xAxisFontSize / 2
            textWidth = -textWidth
          }
          context.translate(offsetX, offsetY)
          context.rotate(-1 * config._xAxisTextAngle_)
          context.fillText(String(xitem), textWidth, 0)
          context.closePath()
          context.stroke()
          context.restore()
        }
      })
    }
  }
  context.restore()

  //画X轴标题
  if (opts.xAxis.title) {
    context.beginPath()
    context.setFontSize(opts.xAxis.titleFontSize * opts.pix)
    context.setFillStyle(opts.xAxis.titleFontColor)
    context.fillText(
      String(opts.xAxis.title),
      opts.width - opts.area[1] + opts.xAxis.titleOffsetX * opts.pix,
      opts.height -
        opts.area[2] +
        opts.xAxis.marginTop * opts.pix +
        ((opts.xAxis.lineHeight - opts.xAxis.titleFontSize) * opts.pix) / 2 +
        (opts.xAxis.titleFontSize + opts.xAxis.titleOffsetY) * opts.pix
    )
    context.closePath()
    context.stroke()
  }

  //绘制X轴轴线
  if (opts.xAxis.axisLine) {
    context.beginPath()
    context.setStrokeStyle(opts.xAxis.axisLineColor)
    context.setLineWidth(1 * opts.pix)
    context.moveTo(startX, opts.height - opts.area[2])
    context.lineTo(endX, opts.height - opts.area[2])
    context.stroke()
  }
}

function drawYAxisGrid(categories, opts, config, context) {
  if (opts.yAxis.disableGrid === true) {
    return
  }
  let spacingValid = opts.height - opts.area[0] - opts.area[2]
  let eachSpacing = spacingValid / opts.yAxis.splitNumber
  let startX = opts.area[3]
  let xAxisPoints = opts.chartData.xAxisData.xAxisPoints,
    xAxiseachSpacing = opts.chartData.xAxisData.eachSpacing
  let TotalWidth = xAxiseachSpacing * (xAxisPoints.length - 1)
  if (
    opts.type == 'mount' &&
    opts.extra &&
    opts.extra.mount &&
    opts.extra.mount.widthRatio &&
    opts.extra.mount.widthRatio > 1
  ) {
    if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
    TotalWidth += (opts.extra.mount.widthRatio - 1) * xAxiseachSpacing
  }
  let endX = startX + TotalWidth
  let points = []
  let startY = 1
  if (opts.xAxis.axisLine === false) {
    startY = 0
  }
  for (let i = startY; i < opts.yAxis.splitNumber + 1; i++) {
    points.push(opts.height - opts.area[2] - eachSpacing * i)
  }
  context.save()
  if (opts._scrollDistance_ && opts._scrollDistance_ !== 0) {
    context.translate(opts._scrollDistance_, 0)
  }
  if (opts.yAxis.gridType == 'dash') {
    context.setLineDash([opts.yAxis.dashLength * opts.pix, opts.yAxis.dashLength * opts.pix])
  }
  context.setStrokeStyle(opts.yAxis.gridColor)
  context.setLineWidth(1 * opts.pix)
  points.forEach(function (item, index) {
    context.beginPath()
    context.moveTo(startX, item)
    context.lineTo(endX, item)
    context.stroke()
  })
  context.setLineDash([])
  context.restore()
}

function drawYAxis(series, opts, config, context) {
  if (opts.yAxis.disabled === true) {
    return
  }
  var spacingValid = opts.height - opts.area[0] - opts.area[2]
  var eachSpacing = spacingValid / opts.yAxis.splitNumber
  var startX = opts.area[3]
  var endX = opts.width - opts.area[1]
  var endY = opts.height - opts.area[2]
  // set YAxis background
  context.beginPath()
  context.setFillStyle(opts.background)
  if (
    opts.enableScroll == true &&
    opts.xAxis.scrollPosition &&
    opts.xAxis.scrollPosition !== 'left'
  ) {
    context.fillRect(0, 0, startX, endY + 2 * opts.pix)
  }
  if (
    opts.enableScroll == true &&
    opts.xAxis.scrollPosition &&
    opts.xAxis.scrollPosition !== 'right'
  ) {
    context.fillRect(endX, 0, opts.width, endY + 2 * opts.pix)
  }
  context.closePath()
  context.stroke()

  let tStartLeft = opts.area[3]
  let tStartRight = opts.width - opts.area[1]
  let tStartCenter = opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2
  if (opts.yAxis.data) {
    for (let i = 0; i < opts.yAxis.data.length; i++) {
      let yData = opts.yAxis.data[i]
      var points = []
      if (yData.type === 'categories') {
        for (let i = 0; i <= yData.categories.length; i++) {
          points.push(
            opts.area[0] +
              spacingValid / yData.categories.length / 2 +
              (spacingValid / yData.categories.length) * i
          )
        }
      } else {
        for (let i = 0; i <= opts.yAxis.splitNumber; i++) {
          points.push(opts.area[0] + eachSpacing * i)
        }
      }
      if (yData.disabled !== true) {
        let rangesFormat = opts.chartData.yAxisData.rangesFormat[i]
        let yAxisFontSize = yData.fontSize ? yData.fontSize * opts.pix : config.fontSize
        let yAxisWidth = opts.chartData.yAxisData.yAxisWidth[i]
        let textAlign = yData.textAlign || 'right'
        //画Y轴刻度及文案
        rangesFormat.forEach(function (item, index) {
          var pos = points[index]
          context.beginPath()
          context.setFontSize(yAxisFontSize)
          context.setLineWidth(1 * opts.pix)
          context.setStrokeStyle(yData.axisLineColor || '#cccccc')
          context.setFillStyle(yData.fontColor || opts.fontColor)
          let tmpstrat = 0
          let gapwidth = 4 * opts.pix
          if (yAxisWidth.position == 'left') {
            //画刻度线
            if (yData.calibration == true) {
              context.moveTo(tStartLeft, pos)
              context.lineTo(tStartLeft - 3 * opts.pix, pos)
              gapwidth += 3 * opts.pix
            }
            //画文字
            switch (textAlign) {
              case 'left':
                context.setTextAlign('left')
                tmpstrat = tStartLeft - yAxisWidth.width
                break
              case 'right':
                context.setTextAlign('right')
                tmpstrat = tStartLeft - gapwidth
                break
              default:
                context.setTextAlign('center')
                tmpstrat = tStartLeft - yAxisWidth.width / 2
            }
            context.fillText(String(item), tmpstrat, pos + yAxisFontSize / 2 - 3 * opts.pix)
          } else if (yAxisWidth.position == 'right') {
            //画刻度线
            if (yData.calibration == true) {
              context.moveTo(tStartRight, pos)
              context.lineTo(tStartRight + 3 * opts.pix, pos)
              gapwidth += 3 * opts.pix
            }
            switch (textAlign) {
              case 'left':
                context.setTextAlign('left')
                tmpstrat = tStartRight + gapwidth
                break
              case 'right':
                context.setTextAlign('right')
                tmpstrat = tStartRight + yAxisWidth.width
                break
              default:
                context.setTextAlign('center')
                tmpstrat = tStartRight + yAxisWidth.width / 2
            }
            context.fillText(String(item), tmpstrat, pos + yAxisFontSize / 2 - 3 * opts.pix)
          } else if (yAxisWidth.position == 'center') {
            //画刻度线
            if (yData.calibration == true) {
              context.moveTo(tStartCenter, pos)
              context.lineTo(tStartCenter - 3 * opts.pix, pos)
              gapwidth += 3 * opts.pix
            }
            //画文字
            switch (textAlign) {
              case 'left':
                context.setTextAlign('left')
                tmpstrat = tStartCenter - yAxisWidth.width
                break
              case 'right':
                context.setTextAlign('right')
                tmpstrat = tStartCenter - gapwidth
                break
              default:
                context.setTextAlign('center')
                tmpstrat = tStartCenter - yAxisWidth.width / 2
            }
            context.fillText(String(item), tmpstrat, pos + yAxisFontSize / 2 - 3 * opts.pix)
          }
          context.closePath()
          context.stroke()
          context.setTextAlign('left')
        })
        //画Y轴轴线
        if (yData.axisLine !== false) {
          context.beginPath()
          context.setStrokeStyle(yData.axisLineColor || '#cccccc')
          context.setLineWidth(1 * opts.pix)
          if (yAxisWidth.position == 'left') {
            context.moveTo(tStartLeft, opts.height - opts.area[2])
            context.lineTo(tStartLeft, opts.area[0])
          } else if (yAxisWidth.position == 'right') {
            context.moveTo(tStartRight, opts.height - opts.area[2])
            context.lineTo(tStartRight, opts.area[0])
          } else if (yAxisWidth.position == 'center') {
            context.moveTo(tStartCenter, opts.height - opts.area[2])
            context.lineTo(tStartCenter, opts.area[0])
          }
          context.stroke()
        }
        //画Y轴标题
        if (opts.yAxis.showTitle) {
          let titleFontSize = yData.titleFontSize * opts.pix || config.fontSize
          let title = yData.title
          context.beginPath()
          context.setFontSize(titleFontSize)
          context.setFillStyle(yData.titleFontColor || opts.fontColor)
          if (yAxisWidth.position == 'left') {
            context.fillText(
              title,
              tStartLeft -
                measureText(title, titleFontSize, context) / 2 +
                (yData.titleOffsetX || 0),
              opts.area[0] - (10 - (yData.titleOffsetY || 0)) * opts.pix
            )
          } else if (yAxisWidth.position == 'right') {
            context.fillText(
              title,
              tStartRight -
                measureText(title, titleFontSize, context) / 2 +
                (yData.titleOffsetX || 0),
              opts.area[0] - (10 - (yData.titleOffsetY || 0)) * opts.pix
            )
          } else if (yAxisWidth.position == 'center') {
            context.fillText(
              title,
              tStartCenter -
                measureText(title, titleFontSize, context) / 2 +
                (yData.titleOffsetX || 0),
              opts.area[0] - (10 - (yData.titleOffsetY || 0)) * opts.pix
            )
          }
          context.closePath()
          context.stroke()
        }
        if (yAxisWidth.position == 'left') {
          tStartLeft -= yAxisWidth.width + opts.yAxis.padding * opts.pix
        } else {
          tStartRight += yAxisWidth.width + opts.yAxis.padding * opts.pix
        }
      }
    }
  }
}

function drawLegend(series, opts, config, context, chartData) {
  if (opts.legend.show === false) {
    return
  }
  let legendData = chartData.legendData
  let legendList = legendData.points
  let legendArea = legendData.area
  let padding = opts.legend.padding * opts.pix
  let fontSize = opts.legend.fontSize * opts.pix
  let shapeWidth = 15 * opts.pix
  let shapeRight = 5 * opts.pix
  let itemGap = opts.legend.itemGap * opts.pix
  let lineHeight = Math.max(opts.legend.lineHeight * opts.pix, fontSize)
  //画背景及边框
  context.beginPath()
  context.setLineWidth(opts.legend.borderWidth * opts.pix)
  context.setStrokeStyle(opts.legend.borderColor)
  context.setFillStyle(opts.legend.backgroundColor)
  context.moveTo(legendArea.start.x, legendArea.start.y)
  context.rect(legendArea.start.x, legendArea.start.y, legendArea.width, legendArea.height)
  context.closePath()
  context.fill()
  context.stroke()
  legendList.forEach(function (itemList, listIndex) {
    let width = 0
    let height = 0
    width = legendData.widthArr[listIndex]
    height = legendData.heightArr[listIndex]
    let startX = 0
    let startY = 0
    if (opts.legend.position == 'top' || opts.legend.position == 'bottom') {
      switch (opts.legend.float) {
        case 'left':
          startX = legendArea.start.x + padding
          break
        case 'right':
          startX = legendArea.start.x + legendArea.width - width
          break
        default:
          startX = legendArea.start.x + (legendArea.width - width) / 2
      }
      startY = legendArea.start.y + padding + listIndex * lineHeight
    } else {
      if (listIndex == 0) {
        width = 0
      } else {
        width = legendData.widthArr[listIndex - 1]
      }
      startX = legendArea.start.x + padding + width
      startY = legendArea.start.y + padding + (legendArea.height - height) / 2
    }
    context.setFontSize(config.fontSize)
    for (let i = 0; i < itemList.length; i++) {
      let item = itemList[i]
      item.area = [0, 0, 0, 0]
      item.area[0] = startX
      item.area[1] = startY
      item.area[3] = startY + lineHeight
      context.beginPath()
      context.setLineWidth(1 * opts.pix)
      context.setStrokeStyle(item.show ? item.color : opts.legend.hiddenColor)
      context.setFillStyle(item.show ? item.color : opts.legend.hiddenColor)
      switch (item.legendShape) {
        case 'line':
          context.moveTo(startX, startY + 0.5 * lineHeight - 2 * opts.pix)
          context.fillRect(
            startX,
            startY + 0.5 * lineHeight - 2 * opts.pix,
            15 * opts.pix,
            4 * opts.pix
          )
          break
        case 'triangle':
          context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight - 5 * opts.pix)
          context.lineTo(startX + 2.5 * opts.pix, startY + 0.5 * lineHeight + 5 * opts.pix)
          context.lineTo(startX + 12.5 * opts.pix, startY + 0.5 * lineHeight + 5 * opts.pix)
          context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight - 5 * opts.pix)
          break
        case 'diamond':
          context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight - 5 * opts.pix)
          context.lineTo(startX + 2.5 * opts.pix, startY + 0.5 * lineHeight)
          context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight + 5 * opts.pix)
          context.lineTo(startX + 12.5 * opts.pix, startY + 0.5 * lineHeight)
          context.lineTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight - 5 * opts.pix)
          break
        case 'circle':
          context.moveTo(startX + 7.5 * opts.pix, startY + 0.5 * lineHeight)
          context.arc(
            startX + 7.5 * opts.pix,
            startY + 0.5 * lineHeight,
            5 * opts.pix,
            0,
            2 * Math.PI
          )
          break
        case 'rect':
          context.moveTo(startX, startY + 0.5 * lineHeight - 5 * opts.pix)
          context.fillRect(
            startX,
            startY + 0.5 * lineHeight - 5 * opts.pix,
            15 * opts.pix,
            10 * opts.pix
          )
          break
        case 'square':
          context.moveTo(startX + 5 * opts.pix, startY + 0.5 * lineHeight - 5 * opts.pix)
          context.fillRect(
            startX + 5 * opts.pix,
            startY + 0.5 * lineHeight - 5 * opts.pix,
            10 * opts.pix,
            10 * opts.pix
          )
          break
        case 'none':
          break
        default:
          context.moveTo(startX, startY + 0.5 * lineHeight - 5 * opts.pix)
          context.fillRect(
            startX,
            startY + 0.5 * lineHeight - 5 * opts.pix,
            15 * opts.pix,
            10 * opts.pix
          )
      }
      context.closePath()
      context.fill()
      context.stroke()
      startX += shapeWidth + shapeRight
      let fontTrans = 0.5 * lineHeight + 0.5 * fontSize - 2
      const legendText = item.legendText ? item.legendText : item.name
      context.beginPath()
      context.setFontSize(fontSize)
      context.setFillStyle(item.show ? opts.legend.fontColor : opts.legend.hiddenColor)
      context.fillText(legendText, startX, startY + fontTrans)
      context.closePath()
      context.stroke()
      if (opts.legend.position == 'top' || opts.legend.position == 'bottom') {
        startX += measureText(legendText, fontSize, context) + itemGap
        item.area[2] = startX
      } else {
        item.area[2] = startX + measureText(legendText, fontSize, context) + itemGap
        startX -= shapeWidth + shapeRight
        startY += lineHeight
      }
    }
  })
}

function drawPieDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var pieOption = assign(
    {},
    {
      activeOpacity: 0.5,
      activeRadius: 10,
      offsetAngle: 0,
      labelWidth: 15,
      ringWidth: 30,
      customRadius: 0,
      border: false,
      borderWidth: 2,
      borderColor: '#FFFFFF',
      centerColor: '#FFFFFF',
      linearType: 'none',
      customColor: []
    },
    opts.type == 'pie' ? opts.extra.pie : opts.extra.ring
  )
  var centerPosition = {
    x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
    y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2
  }
  if (config.pieChartLinePadding == 0) {
    config.pieChartLinePadding = pieOption.activeRadius * opts.pix
  }

  var radius = Math.min(
    (opts.width - opts.area[1] - opts.area[3]) / 2 -
      config.pieChartLinePadding -
      config.pieChartTextPadding -
      config._pieTextMaxLength_,
    (opts.height - opts.area[0] - opts.area[2]) / 2 -
      config.pieChartLinePadding -
      config.pieChartTextPadding
  )
  radius = radius < 10 ? 10 : radius
  if (pieOption.customRadius > 0) {
    radius = pieOption.customRadius * opts.pix
  }
  series = getPieDataPoints(series, radius, process)
  var activeRadius = pieOption.activeRadius * opts.pix
  pieOption.customColor = fillCustomColor(
    pieOption.linearType,
    pieOption.customColor,
    series,
    config
  )
  series = series.map(function (eachSeries) {
    eachSeries._start_ += (pieOption.offsetAngle * Math.PI) / 180
    return eachSeries
  })
  series.forEach(function (eachSeries, seriesIndex) {
    if (opts.tooltip) {
      if (opts.tooltip.index == seriesIndex) {
        context.beginPath()
        context.setFillStyle(hexToRgb(eachSeries.color, pieOption.activeOpacity || 0.5))
        context.moveTo(centerPosition.x, centerPosition.y)
        context.arc(
          centerPosition.x,
          centerPosition.y,
          eachSeries._radius_ + activeRadius,
          eachSeries._start_,
          eachSeries._start_ + 2 * eachSeries._proportion_ * Math.PI
        )
        context.closePath()
        context.fill()
      }
    }
    context.beginPath()
    context.setLineWidth(pieOption.borderWidth * opts.pix)
    context.lineJoin = 'round'
    context.setStrokeStyle(pieOption.borderColor)
    var fillcolor = eachSeries.color
    if (pieOption.linearType == 'custom') {
      var grd
      if (context.createCircularGradient) {
        grd = context.createCircularGradient(
          centerPosition.x,
          centerPosition.y,
          eachSeries._radius_
        )
      } else {
        grd = context.createRadialGradient(
          centerPosition.x,
          centerPosition.y,
          0,
          centerPosition.x,
          centerPosition.y,
          eachSeries._radius_
        )
      }
      grd.addColorStop(0, hexToRgb(pieOption.customColor[eachSeries.linearIndex], 1))
      grd.addColorStop(1, hexToRgb(eachSeries.color, 1))
      fillcolor = grd
    }
    context.setFillStyle(fillcolor)
    context.moveTo(centerPosition.x, centerPosition.y)
    context.arc(
      centerPosition.x,
      centerPosition.y,
      eachSeries._radius_,
      eachSeries._start_,
      eachSeries._start_ + 2 * eachSeries._proportion_ * Math.PI
    )
    context.closePath()
    context.fill()
    if (pieOption.border == true) {
      context.stroke()
    }
  })
  if (opts.type === 'ring') {
    var innerPieWidth = radius * 0.6
    if (typeof pieOption.ringWidth === 'number' && pieOption.ringWidth > 0) {
      innerPieWidth = Math.max(0, radius - pieOption.ringWidth * opts.pix)
    }
    context.beginPath()
    context.setFillStyle(pieOption.centerColor)
    context.moveTo(centerPosition.x, centerPosition.y)
    context.arc(centerPosition.x, centerPosition.y, innerPieWidth, 0, 2 * Math.PI)
    context.closePath()
    context.fill()
  }
  if (opts.dataLabel !== false && process === 1) {
    drawPieText(series, opts, config, context, radius, centerPosition)
  }
  if (process === 1 && opts.type === 'ring') {
    drawRingTitle(opts, config, context, centerPosition)
  }
  return {
    center: centerPosition,
    radius: radius,
    series: series
  }
}

function drawRoseDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var roseOption = assign(
    {},
    {
      type: 'area',
      activeOpacity: 0.5,
      activeRadius: 10,
      offsetAngle: 0,
      labelWidth: 15,
      border: false,
      borderWidth: 2,
      borderColor: '#FFFFFF',
      linearType: 'none',
      customColor: []
    },
    opts.extra.rose
  )
  if (config.pieChartLinePadding == 0) {
    config.pieChartLinePadding = roseOption.activeRadius * opts.pix
  }
  var centerPosition = {
    x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
    y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2
  }
  var radius = Math.min(
    (opts.width - opts.area[1] - opts.area[3]) / 2 -
      config.pieChartLinePadding -
      config.pieChartTextPadding -
      config._pieTextMaxLength_,
    (opts.height - opts.area[0] - opts.area[2]) / 2 -
      config.pieChartLinePadding -
      config.pieChartTextPadding
  )
  radius = radius < 10 ? 10 : radius
  var minRadius = roseOption.minRadius || radius * 0.5
  if (radius < minRadius) {
    radius = minRadius + 10
  }
  series = getRoseDataPoints(series, roseOption.type, minRadius, radius, process)
  var activeRadius = roseOption.activeRadius * opts.pix
  roseOption.customColor = fillCustomColor(
    roseOption.linearType,
    roseOption.customColor,
    series,
    config
  )
  series = series.map(function (eachSeries) {
    eachSeries._start_ += ((roseOption.offsetAngle || 0) * Math.PI) / 180
    return eachSeries
  })
  series.forEach(function (eachSeries, seriesIndex) {
    if (opts.tooltip) {
      if (opts.tooltip.index == seriesIndex) {
        context.beginPath()
        context.setFillStyle(hexToRgb(eachSeries.color, roseOption.activeOpacity || 0.5))
        context.moveTo(centerPosition.x, centerPosition.y)
        context.arc(
          centerPosition.x,
          centerPosition.y,
          activeRadius + eachSeries._radius_,
          eachSeries._start_,
          eachSeries._start_ + 2 * eachSeries._rose_proportion_ * Math.PI
        )
        context.closePath()
        context.fill()
      }
    }
    context.beginPath()
    context.setLineWidth(roseOption.borderWidth * opts.pix)
    context.lineJoin = 'round'
    context.setStrokeStyle(roseOption.borderColor)
    var fillcolor = eachSeries.color
    if (roseOption.linearType == 'custom') {
      var grd
      if (context.createCircularGradient) {
        grd = context.createCircularGradient(
          centerPosition.x,
          centerPosition.y,
          eachSeries._radius_
        )
      } else {
        grd = context.createRadialGradient(
          centerPosition.x,
          centerPosition.y,
          0,
          centerPosition.x,
          centerPosition.y,
          eachSeries._radius_
        )
      }
      grd.addColorStop(0, hexToRgb(roseOption.customColor[eachSeries.linearIndex], 1))
      grd.addColorStop(1, hexToRgb(eachSeries.color, 1))
      fillcolor = grd
    }
    context.setFillStyle(fillcolor)
    context.moveTo(centerPosition.x, centerPosition.y)
    context.arc(
      centerPosition.x,
      centerPosition.y,
      eachSeries._radius_,
      eachSeries._start_,
      eachSeries._start_ + 2 * eachSeries._rose_proportion_ * Math.PI
    )
    context.closePath()
    context.fill()
    if (roseOption.border == true) {
      context.stroke()
    }
  })

  if (opts.dataLabel !== false && process === 1) {
    drawPieText(series, opts, config, context, radius, centerPosition)
  }
  return {
    center: centerPosition,
    radius: radius,
    series: series
  }
}

function drawArcbarDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var arcbarOption = assign(
    {},
    {
      startAngle: 0.75,
      endAngle: 0.25,
      type: 'default',
      direction: 'cw',
      lineCap: 'round',
      width: 12,
      gap: 2,
      linearType: 'none',
      customColor: []
    },
    opts.extra.arcbar
  )
  series = getArcbarDataPoints(series, arcbarOption, process)
  var centerPosition
  if (arcbarOption.centerX || arcbarOption.centerY) {
    centerPosition = {
      x: arcbarOption.centerX ? arcbarOption.centerX : opts.width / 2,
      y: arcbarOption.centerY ? arcbarOption.centerY : opts.height / 2
    }
  } else {
    centerPosition = {
      x: opts.width / 2,
      y: opts.height / 2
    }
  }
  var radius
  if (arcbarOption.radius) {
    radius = arcbarOption.radius
  } else {
    radius = Math.min(centerPosition.x, centerPosition.y)
    radius -= 5 * opts.pix
    radius -= arcbarOption.width / 2
  }
  radius = radius < 10 ? 10 : radius
  arcbarOption.customColor = fillCustomColor(
    arcbarOption.linearType,
    arcbarOption.customColor,
    series,
    config
  )

  for (let i = 0; i < series.length; i++) {
    let eachSeries = series[i]
    //背景颜色
    context.setLineWidth(arcbarOption.width * opts.pix)
    context.setStrokeStyle(arcbarOption.backgroundColor || '#E9E9E9')
    context.setLineCap(arcbarOption.lineCap)
    context.beginPath()
    if (arcbarOption.type == 'default') {
      context.arc(
        centerPosition.x,
        centerPosition.y,
        radius - (arcbarOption.width * opts.pix + arcbarOption.gap * opts.pix) * i,
        arcbarOption.startAngle * Math.PI,
        arcbarOption.endAngle * Math.PI,
        arcbarOption.direction == 'ccw'
      )
    } else {
      context.arc(
        centerPosition.x,
        centerPosition.y,
        radius - (arcbarOption.width * opts.pix + arcbarOption.gap * opts.pix) * i,
        0,
        2 * Math.PI,
        arcbarOption.direction == 'ccw'
      )
    }
    context.stroke()
    //进度条
    var fillColor = eachSeries.color
    if (arcbarOption.linearType == 'custom') {
      var grd = context.createLinearGradient(
        centerPosition.x - radius,
        centerPosition.y,
        centerPosition.x + radius,
        centerPosition.y
      )
      grd.addColorStop(1, hexToRgb(arcbarOption.customColor[eachSeries.linearIndex], 1))
      grd.addColorStop(0, hexToRgb(eachSeries.color, 1))
      fillColor = grd
    }
    context.setLineWidth(arcbarOption.width * opts.pix)
    context.setStrokeStyle(fillColor)
    context.setLineCap(arcbarOption.lineCap)
    context.beginPath()
    context.arc(
      centerPosition.x,
      centerPosition.y,
      radius - (arcbarOption.width * opts.pix + arcbarOption.gap * opts.pix) * i,
      arcbarOption.startAngle * Math.PI,
      eachSeries._proportion_ * Math.PI,
      arcbarOption.direction == 'ccw'
    )
    context.stroke()
  }
  drawRingTitle(opts, config, context, centerPosition)
  return {
    center: centerPosition,
    radius: radius,
    series: series
  }
}

function drawGaugeDataPoints(categories, series, opts, config, context) {
  var process = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
  var gaugeOption = assign(
    {},
    {
      type: 'default',
      startAngle: 0.75,
      endAngle: 0.25,
      width: 15,
      labelOffset: 13,
      splitLine: {
        fixRadius: 0,
        splitNumber: 10,
        width: 15,
        color: '#FFFFFF',
        childNumber: 5,
        childWidth: 5
      },
      pointer: {
        width: 15,
        color: 'auto'
      }
    },
    opts.extra.gauge
  )
  if (gaugeOption.oldAngle == undefined) {
    gaugeOption.oldAngle = gaugeOption.startAngle
  }
  if (gaugeOption.oldData == undefined) {
    gaugeOption.oldData = 0
  }
  categories = getGaugeAxisPoints(categories, gaugeOption.startAngle, gaugeOption.endAngle)
  var centerPosition = {
    x: opts.width / 2,
    y: opts.height / 2
  }
  var radius = Math.min(centerPosition.x, centerPosition.y)
  radius -= 5 * opts.pix
  radius -= gaugeOption.width / 2
  radius = radius < 10 ? 10 : radius
  var innerRadius = radius - gaugeOption.width
  var totalAngle = 0
  //判断仪表盘的样式：default百度样式，progress新样式
  if (gaugeOption.type == 'progress') {
    //## 第一步画中心圆形背景和进度条背景
    //中心圆形背景
    var pieRadius = radius - gaugeOption.width * 3
    context.beginPath()
    let gradient = context.createLinearGradient(
      centerPosition.x,
      centerPosition.y - pieRadius,
      centerPosition.x,
      centerPosition.y + pieRadius
    )
    //配置渐变填充（起点：中心点向上减半径；结束点中心点向下加半径）
    gradient.addColorStop('0', hexToRgb(series[0].color, 0.3))
    gradient.addColorStop('1.0', hexToRgb('#FFFFFF', 0.1))
    context.setFillStyle(gradient)
    context.arc(centerPosition.x, centerPosition.y, pieRadius, 0, 2 * Math.PI, false)
    context.fill()
    //画进度条背景
    context.setLineWidth(gaugeOption.width)
    context.setStrokeStyle(hexToRgb(series[0].color, 0.3))
    context.setLineCap('round')
    context.beginPath()
    context.arc(
      centerPosition.x,
      centerPosition.y,
      innerRadius,
      gaugeOption.startAngle * Math.PI,
      gaugeOption.endAngle * Math.PI,
      false
    )
    context.stroke()
    //## 第二步画刻度线
    if (gaugeOption.endAngle < gaugeOption.startAngle) {
      totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
    } else {
      totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
    }
    let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
    let childAngle =
      totalAngle / gaugeOption.splitLine.splitNumber / gaugeOption.splitLine.childNumber
    let startX = -radius - gaugeOption.width * 0.5 - gaugeOption.splitLine.fixRadius
    let endX =
      -radius - gaugeOption.width - gaugeOption.splitLine.fixRadius + gaugeOption.splitLine.width
    context.save()
    context.translate(centerPosition.x, centerPosition.y)
    context.rotate((gaugeOption.startAngle - 1) * Math.PI)
    let len = gaugeOption.splitLine.splitNumber * gaugeOption.splitLine.childNumber + 1
    let proc = series[0].data * process
    for (let i = 0; i < len; i++) {
      context.beginPath()
      //刻度线随进度变色
      if (proc > i / len) {
        context.setStrokeStyle(hexToRgb(series[0].color, 1))
      } else {
        context.setStrokeStyle(hexToRgb(series[0].color, 0.3))
      }
      context.setLineWidth(3 * opts.pix)
      context.moveTo(startX, 0)
      context.lineTo(endX, 0)
      context.stroke()
      context.rotate(childAngle * Math.PI)
    }
    context.restore()
    //## 第三步画进度条
    series = getGaugeArcbarDataPoints(series, gaugeOption, process)
    context.setLineWidth(gaugeOption.width)
    context.setStrokeStyle(series[0].color)
    context.setLineCap('round')
    context.beginPath()
    context.arc(
      centerPosition.x,
      centerPosition.y,
      innerRadius,
      gaugeOption.startAngle * Math.PI,
      series[0]._proportion_ * Math.PI,
      false
    )
    context.stroke()
    //## 第四步画指针
    let pointerRadius = radius - gaugeOption.width * 2.5
    context.save()
    context.translate(centerPosition.x, centerPosition.y)
    context.rotate((series[0]._proportion_ - 1) * Math.PI)
    context.beginPath()
    context.setLineWidth(gaugeOption.width / 3)
    let gradient3 = context.createLinearGradient(0, -pointerRadius * 0.6, 0, pointerRadius * 0.6)
    gradient3.addColorStop('0', hexToRgb('#FFFFFF', 0))
    gradient3.addColorStop('0.5', hexToRgb(series[0].color, 1))
    gradient3.addColorStop('1.0', hexToRgb('#FFFFFF', 0))
    context.setStrokeStyle(gradient3)
    context.arc(0, 0, pointerRadius, 0.85 * Math.PI, 1.15 * Math.PI, false)
    context.stroke()
    context.beginPath()
    context.setLineWidth(1)
    context.setStrokeStyle(series[0].color)
    context.setFillStyle(series[0].color)
    context.moveTo(-pointerRadius - gaugeOption.width / 3 / 2, -4)
    context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2 - 4, 0)
    context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2, 4)
    context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2, -4)
    context.stroke()
    context.fill()
    context.restore()
    //default百度样式
  } else {
    //画背景
    context.setLineWidth(gaugeOption.width)
    context.setLineCap('butt')
    for (let i = 0; i < categories.length; i++) {
      let eachCategories = categories[i]
      context.beginPath()
      context.setStrokeStyle(eachCategories.color)
      context.arc(
        centerPosition.x,
        centerPosition.y,
        radius,
        eachCategories._startAngle_ * Math.PI,
        eachCategories._endAngle_ * Math.PI,
        false
      )
      context.stroke()
    }
    context.save()
    //画刻度线
    if (gaugeOption.endAngle < gaugeOption.startAngle) {
      totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
    } else {
      totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
    }
    let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
    let childAngle =
      totalAngle / gaugeOption.splitLine.splitNumber / gaugeOption.splitLine.childNumber
    let startX = -radius - gaugeOption.width * 0.5 - gaugeOption.splitLine.fixRadius
    let endX =
      -radius -
      gaugeOption.width * 0.5 -
      gaugeOption.splitLine.fixRadius +
      gaugeOption.splitLine.width
    let childendX =
      -radius -
      gaugeOption.width * 0.5 -
      gaugeOption.splitLine.fixRadius +
      gaugeOption.splitLine.childWidth
    context.translate(centerPosition.x, centerPosition.y)
    context.rotate((gaugeOption.startAngle - 1) * Math.PI)
    for (let i = 0; i < gaugeOption.splitLine.splitNumber + 1; i++) {
      context.beginPath()
      context.setStrokeStyle(gaugeOption.splitLine.color)
      context.setLineWidth(2 * opts.pix)
      context.moveTo(startX, 0)
      context.lineTo(endX, 0)
      context.stroke()
      context.rotate(splitAngle * Math.PI)
    }
    context.restore()
    context.save()
    context.translate(centerPosition.x, centerPosition.y)
    context.rotate((gaugeOption.startAngle - 1) * Math.PI)
    for (
      let i = 0;
      i < gaugeOption.splitLine.splitNumber * gaugeOption.splitLine.childNumber + 1;
      i++
    ) {
      context.beginPath()
      context.setStrokeStyle(gaugeOption.splitLine.color)
      context.setLineWidth(1 * opts.pix)
      context.moveTo(startX, 0)
      context.lineTo(childendX, 0)
      context.stroke()
      context.rotate(childAngle * Math.PI)
    }
    context.restore()
    //画指针
    series = getGaugeDataPoints(series, categories, gaugeOption, process)
    for (let i = 0; i < series.length; i++) {
      let eachSeries = series[i]
      context.save()
      context.translate(centerPosition.x, centerPosition.y)
      context.rotate((eachSeries._proportion_ - 1) * Math.PI)
      context.beginPath()
      context.setFillStyle(eachSeries.color)
      context.moveTo(gaugeOption.pointer.width, 0)
      context.lineTo(0, -gaugeOption.pointer.width / 2)
      context.lineTo(-innerRadius, 0)
      context.lineTo(0, gaugeOption.pointer.width / 2)
      context.lineTo(gaugeOption.pointer.width, 0)
      context.closePath()
      context.fill()
      context.beginPath()
      context.setFillStyle('#FFFFFF')
      context.arc(0, 0, gaugeOption.pointer.width / 6, 0, 2 * Math.PI, false)
      context.fill()
      context.restore()
    }
    if (opts.dataLabel !== false) {
      drawGaugeLabel(gaugeOption, radius, centerPosition, opts, config, context)
    }
  }
  //画仪表盘标题，副标题
  drawRingTitle(opts, config, context, centerPosition)
  if (process === 1 && opts.type === 'gauge') {
    opts.extra.gauge.oldAngle = series[0]._proportion_
    opts.extra.gauge.oldData = series[0].data
  }
  return {
    center: centerPosition,
    radius: radius,
    innerRadius: innerRadius,
    categories: categories,
    totalAngle: totalAngle
  }
}

function drawRadarDataPoints(series, opts, config, context) {
  var process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  var radarOption = assign(
    {},
    {
      gridColor: '#cccccc',
      gridType: 'radar',
      gridEval: 1,
      axisLabel: false,
      axisLabelTofix: 0,
      labelShow: true,
      labelColor: '#666666',
      labelPointShow: false,
      labelPointRadius: 3,
      labelPointColor: '#cccccc',
      opacity: 0.2,
      gridCount: 3,
      border: false,
      borderWidth: 2,
      linearType: 'none',
      customColor: []
    },
    opts.extra.radar
  )
  var coordinateAngle = getRadarCoordinateSeries(opts.categories.length)
  var centerPosition = {
    x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
    y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2
  }
  var xr = (opts.width - opts.area[1] - opts.area[3]) / 2
  var yr = (opts.height - opts.area[0] - opts.area[2]) / 2
  var radius = Math.min(
    xr -
      (getMaxTextListLength(opts.categories, config.fontSize, context) +
        config.radarLabelTextMargin),
    yr - config.radarLabelTextMargin
  )
  radius -= config.radarLabelTextMargin * opts.pix
  radius = radius < 10 ? 10 : radius
  radius = radarOption.radius ? radarOption.radius : radius
  // 画分割线
  context.beginPath()
  context.setLineWidth(1 * opts.pix)
  context.setStrokeStyle(radarOption.gridColor)
  coordinateAngle.forEach(function (angle, index) {
    var pos = convertCoordinateOrigin(
      radius * Math.cos(angle),
      radius * Math.sin(angle),
      centerPosition
    )
    context.moveTo(centerPosition.x, centerPosition.y)
    if (index % radarOption.gridEval == 0) {
      context.lineTo(pos.x, pos.y)
    }
  })
  context.stroke()
  context.closePath()

  // 画背景网格
  var _loop = function _loop(i) {
    var startPos = {}
    context.beginPath()
    context.setLineWidth(1 * opts.pix)
    context.setStrokeStyle(radarOption.gridColor)
    if (radarOption.gridType == 'radar') {
      coordinateAngle.forEach(function (angle, index) {
        var pos = convertCoordinateOrigin(
          (radius / radarOption.gridCount) * i * Math.cos(angle),
          (radius / radarOption.gridCount) * i * Math.sin(angle),
          centerPosition
        )
        if (index === 0) {
          startPos = pos
          context.moveTo(pos.x, pos.y)
        } else {
          context.lineTo(pos.x, pos.y)
        }
      })
      context.lineTo(startPos.x, startPos.y)
    } else {
      var pos = convertCoordinateOrigin(
        (radius / radarOption.gridCount) * i * Math.cos(1.5),
        (radius / radarOption.gridCount) * i * Math.sin(1.5),
        centerPosition
      )
      context.arc(
        centerPosition.x,
        centerPosition.y,
        centerPosition.y - pos.y,
        0,
        2 * Math.PI,
        false
      )
    }
    context.stroke()
    context.closePath()
  }
  for (var i = 1; i <= radarOption.gridCount; i++) {
    _loop(i)
  }
  radarOption.customColor = fillCustomColor(
    radarOption.linearType,
    radarOption.customColor,
    series,
    config
  )
  var radarDataPoints = getRadarDataPoints(
    coordinateAngle,
    centerPosition,
    radius,
    series,
    opts,
    process
  )
  radarDataPoints.forEach(function (eachSeries, seriesIndex) {
    // 绘制区域数据
    context.beginPath()
    context.setLineWidth(radarOption.borderWidth * opts.pix)
    context.setStrokeStyle(eachSeries.color)

    var fillcolor = hexToRgb(eachSeries.color, radarOption.opacity)
    if (radarOption.linearType == 'custom') {
      var grd
      if (context.createCircularGradient) {
        grd = context.createCircularGradient(centerPosition.x, centerPosition.y, radius)
      } else {
        grd = context.createRadialGradient(
          centerPosition.x,
          centerPosition.y,
          0,
          centerPosition.x,
          centerPosition.y,
          radius
        )
      }
      grd.addColorStop(
        0,
        hexToRgb(radarOption.customColor[series[seriesIndex].linearIndex], radarOption.opacity)
      )
      grd.addColorStop(1, hexToRgb(eachSeries.color, radarOption.opacity))
      fillcolor = grd
    }

    context.setFillStyle(fillcolor)
    eachSeries.data.forEach(function (item, index) {
      if (index === 0) {
        context.moveTo(item.position.x, item.position.y)
      } else {
        context.lineTo(item.position.x, item.position.y)
      }
    })
    context.closePath()
    context.fill()
    if (radarOption.border === true) {
      context.stroke()
    }
    context.closePath()
    if (opts.dataPointShape !== false) {
      var points = eachSeries.data.map(function (item) {
        return item.position
      })
      drawPointShape(points, eachSeries.color, eachSeries.pointShape, context, opts)
    }
  })
  // 画刻度值
  if (radarOption.axisLabel === true) {
    const maxData = Math.max(radarOption.max, Math.max.apply(null, dataCombine(series)))
    const stepLength = radius / radarOption.gridCount
    const fontSize = opts.fontSize * opts.pix
    context.setFontSize(fontSize)
    context.setFillStyle(opts.fontColor)
    context.setTextAlign('left')
    for (var i = 0; i < radarOption.gridCount + 1; i++) {
      let label = (i * maxData) / radarOption.gridCount
      label = label.toFixed(radarOption.axisLabelTofix)
      context.fillText(
        String(label),
        centerPosition.x + 3 * opts.pix,
        centerPosition.y - i * stepLength + fontSize / 2
      )
    }
  }

  // draw label text
  drawRadarLabel(coordinateAngle, radius, centerPosition, opts, config, context)

  // draw dataLabel
  if (opts.dataLabel !== false && process === 1) {
    radarDataPoints.forEach(function (eachSeries, seriesIndex) {
      context.beginPath()
      var fontSize = eachSeries.textSize * opts.pix || config.fontSize
      context.setFontSize(fontSize)
      context.setFillStyle(eachSeries.textColor || opts.fontColor)
      eachSeries.data.forEach(function (item, index) {
        //如果是中心点垂直的上下点位
        if (Math.abs(item.position.x - centerPosition.x) < 2) {
          //如果在上面
          if (item.position.y < centerPosition.y) {
            context.setTextAlign('center')
            context.fillText(item.value, item.position.x, item.position.y - 4)
          } else {
            context.setTextAlign('center')
            context.fillText(item.value, item.position.x, item.position.y + fontSize + 2)
          }
        } else {
          //如果在左侧
          if (item.position.x < centerPosition.x) {
            context.setTextAlign('right')
            context.fillText(item.value, item.position.x - 4, item.position.y + fontSize / 2 - 2)
          } else {
            context.setTextAlign('left')
            context.fillText(item.value, item.position.x + 4, item.position.y + fontSize / 2 - 2)
          }
        }
      })
      context.closePath()
      context.stroke()
    })
    context.setTextAlign('left')
  }

  return {
    center: centerPosition,
    radius: radius,
    angleList: coordinateAngle
  }
}

// 经纬度转墨卡托
function lonlat2mercator(longitude, latitude) {
  var mercator = Array(2)
  var x = (longitude * 20037508.34) / 180
  var y = Math.log(Math.tan(((90 + latitude) * Math.PI) / 360)) / (Math.PI / 180)
  y = (y * 20037508.34) / 180
  mercator[0] = x
  mercator[1] = y
  return mercator
}

// 墨卡托转经纬度
function mercator2lonlat(longitude, latitude) {
  var lonlat = Array(2)
  var x = (longitude / 20037508.34) * 180
  var y = (latitude / 20037508.34) * 180
  y = (180 / Math.PI) * (2 * Math.atan(Math.exp((y * Math.PI) / 180)) - Math.PI / 2)
  lonlat[0] = x
  lonlat[1] = y
  return lonlat
}

function getBoundingBox(data) {
  var bounds = {},
    coords
  bounds.xMin = 180
  bounds.xMax = 0
  bounds.yMin = 90
  bounds.yMax = 0
  for (var i = 0; i < data.length; i++) {
    var coorda = data[i].geometry.coordinates
    for (var k = 0; k < coorda.length; k++) {
      coords = coorda[k]
      if (coords.length == 1) {
        coords = coords[0]
      }
      for (var j = 0; j < coords.length; j++) {
        var longitude = coords[j][0]
        var latitude = coords[j][1]
        var point = {
          x: longitude,
          y: latitude
        }
        bounds.xMin = bounds.xMin < point.x ? bounds.xMin : point.x
        bounds.xMax = bounds.xMax > point.x ? bounds.xMax : point.x
        bounds.yMin = bounds.yMin < point.y ? bounds.yMin : point.y
        bounds.yMax = bounds.yMax > point.y ? bounds.yMax : point.y
      }
    }
  }
  return bounds
}

function coordinateToPoint(latitude, longitude, bounds, scale, xoffset, yoffset) {
  return {
    x: (longitude - bounds.xMin) * scale + xoffset,
    y: (bounds.yMax - latitude) * scale + yoffset
  }
}

function pointToCoordinate(pointY, pointX, bounds, scale, xoffset, yoffset) {
  return {
    x: (pointX - xoffset) / scale + bounds.xMin,
    y: bounds.yMax - (pointY - yoffset) / scale
  }
}

function isRayIntersectsSegment(poi, s_poi, e_poi) {
  if (s_poi[1] == e_poi[1]) {
    return false
  }
  if (s_poi[1] > poi[1] && e_poi[1] > poi[1]) {
    return false
  }
  if (s_poi[1] < poi[1] && e_poi[1] < poi[1]) {
    return false
  }
  if (s_poi[1] == poi[1] && e_poi[1] > poi[1]) {
    return false
  }
  if (e_poi[1] == poi[1] && s_poi[1] > poi[1]) {
    return false
  }
  if (s_poi[0] < poi[0] && e_poi[1] < poi[1]) {
    return false
  }
  let xseg = e_poi[0] - ((e_poi[0] - s_poi[0]) * (e_poi[1] - poi[1])) / (e_poi[1] - s_poi[1])
  if (xseg < poi[0]) {
    return false
  } else {
    return true
  }
}

function isPoiWithinPoly(poi, poly, mercator) {
  let sinsc = 0
  for (let i = 0; i < poly.length; i++) {
    let epoly = poly[i][0]
    if (poly.length == 1) {
      epoly = poly[i][0]
    }
    for (let j = 0; j < epoly.length - 1; j++) {
      let s_poi = epoly[j]
      let e_poi = epoly[j + 1]
      if (mercator) {
        s_poi = lonlat2mercator(epoly[j][0], epoly[j][1])
        e_poi = lonlat2mercator(epoly[j + 1][0], epoly[j + 1][1])
      }
      if (isRayIntersectsSegment(poi, s_poi, e_poi)) {
        sinsc += 1
      }
    }
  }
  if (sinsc % 2 == 1) {
    return true
  } else {
    return false
  }
}

function drawMapDataPoints(series, opts, config, context) {
  var mapOption = assign(
    {},
    {
      border: true,
      mercator: false,
      borderWidth: 1,
      active: true,
      borderColor: '#666666',
      fillOpacity: 0.6,
      activeBorderColor: '#f04864',
      activeFillColor: '#facc14',
      activeFillOpacity: 1
    },
    opts.extra.map
  )
  var coords, point
  var data = series
  var bounds = getBoundingBox(data)
  if (mapOption.mercator) {
    var max = lonlat2mercator(bounds.xMax, bounds.yMax)
    var min = lonlat2mercator(bounds.xMin, bounds.yMin)
    bounds.xMax = max[0]
    bounds.yMax = max[1]
    bounds.xMin = min[0]
    bounds.yMin = min[1]
  }
  var xScale = opts.width / Math.abs(bounds.xMax - bounds.xMin)
  var yScale = opts.height / Math.abs(bounds.yMax - bounds.yMin)
  var scale = xScale < yScale ? xScale : yScale
  var xoffset = opts.width / 2 - (Math.abs(bounds.xMax - bounds.xMin) / 2) * scale
  var yoffset = opts.height / 2 - (Math.abs(bounds.yMax - bounds.yMin) / 2) * scale
  for (var i = 0; i < data.length; i++) {
    context.beginPath()
    context.setLineWidth(mapOption.borderWidth * opts.pix)
    context.setStrokeStyle(mapOption.borderColor)
    context.setFillStyle(hexToRgb(series[i].color, series[i].fillOpacity || mapOption.fillOpacity))
    if (mapOption.active == true && opts.tooltip) {
      if (opts.tooltip.index == i) {
        context.setStrokeStyle(mapOption.activeBorderColor)
        context.setFillStyle(hexToRgb(mapOption.activeFillColor, mapOption.activeFillOpacity))
      }
    }
    var coorda = data[i].geometry.coordinates
    for (var k = 0; k < coorda.length; k++) {
      coords = coorda[k]
      if (coords.length == 1) {
        coords = coords[0]
      }
      for (var j = 0; j < coords.length; j++) {
        var gaosi = Array(2)
        if (mapOption.mercator) {
          gaosi = lonlat2mercator(coords[j][0], coords[j][1])
        } else {
          gaosi = coords[j]
        }
        point = coordinateToPoint(gaosi[1], gaosi[0], bounds, scale, xoffset, yoffset)
        if (j === 0) {
          context.beginPath()
          context.moveTo(point.x, point.y)
        } else {
          context.lineTo(point.x, point.y)
        }
      }
      context.fill()
      if (mapOption.border == true) {
        context.stroke()
      }
    }
  }
  if (opts.dataLabel == true) {
    for (var i = 0; i < data.length; i++) {
      var centerPoint = data[i].properties.centroid
      if (centerPoint) {
        if (mapOption.mercator) {
          centerPoint = lonlat2mercator(
            data[i].properties.centroid[0],
            data[i].properties.centroid[1]
          )
        }
        point = coordinateToPoint(centerPoint[1], centerPoint[0], bounds, scale, xoffset, yoffset)
        let fontSize = data[i].textSize * opts.pix || config.fontSize
        let fontColor = data[i].textColor || opts.fontColor
        if (
          mapOption.active &&
          mapOption.activeTextColor &&
          opts.tooltip &&
          opts.tooltip.index == i
        ) {
          fontColor = mapOption.activeTextColor
        }
        let text = data[i].properties.name
        context.beginPath()
        context.setFontSize(fontSize)
        context.setFillStyle(fontColor)
        context.fillText(
          text,
          point.x - measureText(text, fontSize, context) / 2,
          point.y + fontSize / 2
        )
        context.closePath()
        context.stroke()
      }
    }
  }
  opts.chartData.mapData = {
    bounds: bounds,
    scale: scale,
    xoffset: xoffset,
    yoffset: yoffset,
    mercator: mapOption.mercator
  }
  drawToolTipBridge(opts, config, context, 1)
  context.draw()
}

function normalInt(min, max, iter) {
  iter = iter == 0 ? 1 : iter
  var arr = []
  for (var i = 0; i < iter; i++) {
    arr[i] = Math.random()
  }
  return (
    Math.floor(
      (arr.reduce(function (i, j) {
        return i + j
      }) /
        iter) *
        (max - min)
    ) + min
  )
}

function collisionNew(area, points, width, height) {
  var isIn = false
  for (let i = 0; i < points.length; i++) {
    if (points[i].area) {
      if (
        area[3] < points[i].area[1] ||
        area[0] > points[i].area[2] ||
        area[1] > points[i].area[3] ||
        area[2] < points[i].area[0]
      ) {
        if (area[0] < 0 || area[1] < 0 || area[2] > width || area[3] > height) {
          isIn = true
          break
        } else {
          isIn = false
        }
      } else {
        isIn = true
        break
      }
    }
  }
  return isIn
}

function getWordCloudPoint(opts, type, context) {
  let points = opts.series
  switch (type) {
    case 'normal':
      for (let i = 0; i < points.length; i++) {
        let text = points[i].name
        let tHeight = points[i].textSize * opts.pix
        let tWidth = measureText(text, tHeight, context)
        let x, y
        let area
        let breaknum = 0
        while (true) {
          breaknum++
          x = normalInt(-opts.width / 2, opts.width / 2, 5) - tWidth / 2
          y = normalInt(-opts.height / 2, opts.height / 2, 5) + tHeight / 2
          area = [
            x - 5 + opts.width / 2,
            y - 5 - tHeight + opts.height / 2,
            x + tWidth + 5 + opts.width / 2,
            y + 5 + opts.height / 2
          ]
          let isCollision = collisionNew(area, points, opts.width, opts.height)
          if (!isCollision) break
          if (breaknum == 1000) {
            area = [-100, -100, -100, -100]
            break
          }
        }
        points[i].area = area
      }
      break
    case 'vertical':
      function Spin() {
        //获取均匀随机值，是否旋转，旋转的概率为（1-0.5）
        if (Math.random() > 0.7) {
          return true
        } else {
          return false
        }
      }
      for (let i = 0; i < points.length; i++) {
        let text = points[i].name
        let tHeight = points[i].textSize * opts.pix
        let tWidth = measureText(text, tHeight, context)
        let isSpin = Spin()
        let x, y, area, areav
        let breaknum = 0
        while (true) {
          breaknum++
          let isCollision
          if (isSpin) {
            x = normalInt(-opts.width / 2, opts.width / 2, 5) - tWidth / 2
            y = normalInt(-opts.height / 2, opts.height / 2, 5) + tHeight / 2
            area = [
              y - 5 - tWidth + opts.width / 2,
              -x - 5 + opts.height / 2,
              y + 5 + opts.width / 2,
              -x + tHeight + 5 + opts.height / 2
            ]
            areav = [
              opts.width -
                (opts.width / 2 - opts.height / 2) -
                (-x + tHeight + 5 + opts.height / 2) -
                5,
              opts.height / 2 - opts.width / 2 + (y - 5 - tWidth + opts.width / 2) - 5,
              opts.width -
                (opts.width / 2 - opts.height / 2) -
                (-x + tHeight + 5 + opts.height / 2) +
                tHeight,
              opts.height / 2 - opts.width / 2 + (y - 5 - tWidth + opts.width / 2) + tWidth + 5
            ]
            isCollision = collisionNew(areav, points, opts.height, opts.width)
          } else {
            x = normalInt(-opts.width / 2, opts.width / 2, 5) - tWidth / 2
            y = normalInt(-opts.height / 2, opts.height / 2, 5) + tHeight / 2
            area = [
              x - 5 + opts.width / 2,
              y - 5 - tHeight + opts.height / 2,
              x + tWidth + 5 + opts.width / 2,
              y + 5 + opts.height / 2
            ]
            isCollision = collisionNew(area, points, opts.width, opts.height)
          }
          if (!isCollision) break
          if (breaknum == 1000) {
            area = [-1000, -1000, -1000, -1000]
            break
          }
        }
        if (isSpin) {
          points[i].area = areav
          points[i].areav = area
        } else {
          points[i].area = area
        }
        points[i].rotate = isSpin
      }
      break
  }
  return points
}

function drawWordCloudDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let wordOption = assign(
    {},
    {
      type: 'normal',
      autoColors: true
    },
    opts.extra.word
  )
  if (!opts.chartData.wordCloudData) {
    opts.chartData.wordCloudData = getWordCloudPoint(opts, wordOption.type, context)
  }
  context.beginPath()
  context.setFillStyle(opts.background)
  context.rect(0, 0, opts.width, opts.height)
  context.fill()
  context.save()
  let points = opts.chartData.wordCloudData
  context.translate(opts.width / 2, opts.height / 2)
  for (let i = 0; i < points.length; i++) {
    context.save()
    if (points[i].rotate) {
      context.rotate((90 * Math.PI) / 180)
    }
    let text = points[i].name
    let tHeight = points[i].textSize * opts.pix
    let tWidth = measureText(text, tHeight, context)
    context.beginPath()
    context.setStrokeStyle(points[i].color)
    context.setFillStyle(points[i].color)
    context.setFontSize(tHeight)
    if (points[i].rotate) {
      if (points[i].areav[0] > 0) {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.strokeText(
              text,
              (points[i].areav[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
              (points[i].areav[1] + 5 + tHeight - opts.height / 2) * process
            )
          } else {
            context.fillText(
              text,
              (points[i].areav[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
              (points[i].areav[1] + 5 + tHeight - opts.height / 2) * process
            )
          }
        } else {
          context.fillText(
            text,
            (points[i].areav[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
            (points[i].areav[1] + 5 + tHeight - opts.height / 2) * process
          )
        }
      }
    } else {
      if (points[i].area[0] > 0) {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.strokeText(
              text,
              (points[i].area[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
              (points[i].area[1] + 5 + tHeight - opts.height / 2) * process
            )
          } else {
            context.fillText(
              text,
              (points[i].area[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
              (points[i].area[1] + 5 + tHeight - opts.height / 2) * process
            )
          }
        } else {
          context.fillText(
            text,
            (points[i].area[0] + 5 - opts.width / 2) * process - (tWidth * (1 - process)) / 2,
            (points[i].area[1] + 5 + tHeight - opts.height / 2) * process
          )
        }
      }
    }
    context.stroke()
    context.restore()
  }
  context.restore()
}

function drawFunnelDataPoints(series, opts, config, context) {
  let process = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
  let funnelOption = assign(
    {},
    {
      type: 'funnel',
      activeWidth: 10,
      activeOpacity: 0.3,
      border: false,
      borderWidth: 2,
      borderColor: '#FFFFFF',
      fillOpacity: 1,
      minSize: 0,
      labelAlign: 'right',
      linearType: 'none',
      customColor: []
    },
    opts.extra.funnel
  )
  let eachSpacing = (opts.height - opts.area[0] - opts.area[2]) / series.length
  let centerPosition = {
    x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
    y: opts.height - opts.area[2]
  }
  let activeWidth = funnelOption.activeWidth * opts.pix
  let radius = Math.min(
    (opts.width - opts.area[1] - opts.area[3]) / 2 - activeWidth,
    (opts.height - opts.area[0] - opts.area[2]) / 2 - activeWidth
  )
  let seriesNew = getFunnelDataPoints(series, radius, funnelOption, eachSpacing, process)
  context.save()
  context.translate(centerPosition.x, centerPosition.y)
  funnelOption.customColor = fillCustomColor(
    funnelOption.linearType,
    funnelOption.customColor,
    series,
    config
  )
  if (funnelOption.type == 'pyramid') {
    for (let i = 0; i < seriesNew.length; i++) {
      if (i == seriesNew.length - 1) {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.beginPath()
            context.setFillStyle(hexToRgb(seriesNew[i].color, funnelOption.activeOpacity))
            context.moveTo(-activeWidth, -eachSpacing)
            context.lineTo(-seriesNew[i].radius - activeWidth, 0)
            context.lineTo(seriesNew[i].radius + activeWidth, 0)
            context.lineTo(activeWidth, -eachSpacing)
            context.lineTo(-activeWidth, -eachSpacing)
            context.closePath()
            context.fill()
          }
        }
        seriesNew[i].funnelArea = [
          centerPosition.x - seriesNew[i].radius,
          centerPosition.y - eachSpacing * (i + 1),
          centerPosition.x + seriesNew[i].radius,
          centerPosition.y - eachSpacing * i
        ]
        context.beginPath()
        context.setLineWidth(funnelOption.borderWidth * opts.pix)
        context.setStrokeStyle(funnelOption.borderColor)
        var fillColor = hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
        if (funnelOption.linearType == 'custom') {
          var grd = context.createLinearGradient(
            seriesNew[i].radius,
            -eachSpacing,
            -seriesNew[i].radius,
            -eachSpacing
          )
          grd.addColorStop(0, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          grd.addColorStop(
            0.5,
            hexToRgb(funnelOption.customColor[seriesNew[i].linearIndex], funnelOption.fillOpacity)
          )
          grd.addColorStop(1, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          fillColor = grd
        }
        context.setFillStyle(fillColor)
        context.moveTo(0, -eachSpacing)
        context.lineTo(-seriesNew[i].radius, 0)
        context.lineTo(seriesNew[i].radius, 0)
        context.lineTo(0, -eachSpacing)
        context.closePath()
        context.fill()
        if (funnelOption.border == true) {
          context.stroke()
        }
      } else {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.beginPath()
            context.setFillStyle(hexToRgb(seriesNew[i].color, funnelOption.activeOpacity))
            context.moveTo(0, 0)
            context.lineTo(-seriesNew[i].radius - activeWidth, 0)
            context.lineTo(-seriesNew[i + 1].radius - activeWidth, -eachSpacing)
            context.lineTo(seriesNew[i + 1].radius + activeWidth, -eachSpacing)
            context.lineTo(seriesNew[i].radius + activeWidth, 0)
            context.lineTo(0, 0)
            context.closePath()
            context.fill()
          }
        }
        seriesNew[i].funnelArea = [
          centerPosition.x - seriesNew[i].radius,
          centerPosition.y - eachSpacing * (i + 1),
          centerPosition.x + seriesNew[i].radius,
          centerPosition.y - eachSpacing * i
        ]
        context.beginPath()
        context.setLineWidth(funnelOption.borderWidth * opts.pix)
        context.setStrokeStyle(funnelOption.borderColor)
        var fillColor = hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
        if (funnelOption.linearType == 'custom') {
          var grd = context.createLinearGradient(
            seriesNew[i].radius,
            -eachSpacing,
            -seriesNew[i].radius,
            -eachSpacing
          )
          grd.addColorStop(0, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          grd.addColorStop(
            0.5,
            hexToRgb(funnelOption.customColor[seriesNew[i].linearIndex], funnelOption.fillOpacity)
          )
          grd.addColorStop(1, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          fillColor = grd
        }
        context.setFillStyle(fillColor)
        context.moveTo(0, 0)
        context.lineTo(-seriesNew[i].radius, 0)
        context.lineTo(-seriesNew[i + 1].radius, -eachSpacing)
        context.lineTo(seriesNew[i + 1].radius, -eachSpacing)
        context.lineTo(seriesNew[i].radius, 0)
        context.lineTo(0, 0)
        context.closePath()
        context.fill()
        if (funnelOption.border == true) {
          context.stroke()
        }
      }
      context.translate(0, -eachSpacing)
    }
  } else {
    context.translate(0, -(seriesNew.length - 1) * eachSpacing)
    for (let i = 0; i < seriesNew.length; i++) {
      if (i == seriesNew.length - 1) {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.beginPath()
            context.setFillStyle(hexToRgb(seriesNew[i].color, funnelOption.activeOpacity))
            context.moveTo(-activeWidth - funnelOption.minSize / 2, 0)
            context.lineTo(-seriesNew[i].radius - activeWidth, -eachSpacing)
            context.lineTo(seriesNew[i].radius + activeWidth, -eachSpacing)
            context.lineTo(activeWidth + funnelOption.minSize / 2, 0)
            context.lineTo(-activeWidth - funnelOption.minSize / 2, 0)
            context.closePath()
            context.fill()
          }
        }
        seriesNew[i].funnelArea = [
          centerPosition.x - seriesNew[i].radius,
          centerPosition.y - eachSpacing,
          centerPosition.x + seriesNew[i].radius,
          centerPosition.y
        ]
        context.beginPath()
        context.setLineWidth(funnelOption.borderWidth * opts.pix)
        context.setStrokeStyle(funnelOption.borderColor)
        var fillColor = hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
        if (funnelOption.linearType == 'custom') {
          var grd = context.createLinearGradient(
            seriesNew[i].radius,
            -eachSpacing,
            -seriesNew[i].radius,
            -eachSpacing
          )
          grd.addColorStop(0, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          grd.addColorStop(
            0.5,
            hexToRgb(funnelOption.customColor[seriesNew[i].linearIndex], funnelOption.fillOpacity)
          )
          grd.addColorStop(1, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          fillColor = grd
        }
        context.setFillStyle(fillColor)
        context.moveTo(0, 0)
        context.lineTo(-funnelOption.minSize / 2, 0)
        context.lineTo(-seriesNew[i].radius, -eachSpacing)
        context.lineTo(seriesNew[i].radius, -eachSpacing)
        context.lineTo(funnelOption.minSize / 2, 0)
        context.lineTo(0, 0)
        context.closePath()
        context.fill()
        if (funnelOption.border == true) {
          context.stroke()
        }
      } else {
        if (opts.tooltip) {
          if (opts.tooltip.index == i) {
            context.beginPath()
            context.setFillStyle(hexToRgb(seriesNew[i].color, funnelOption.activeOpacity))
            context.moveTo(0, 0)
            context.lineTo(-seriesNew[i + 1].radius - activeWidth, 0)
            context.lineTo(-seriesNew[i].radius - activeWidth, -eachSpacing)
            context.lineTo(seriesNew[i].radius + activeWidth, -eachSpacing)
            context.lineTo(seriesNew[i + 1].radius + activeWidth, 0)
            context.lineTo(0, 0)
            context.closePath()
            context.fill()
          }
        }
        seriesNew[i].funnelArea = [
          centerPosition.x - seriesNew[i].radius,
          centerPosition.y - eachSpacing * (seriesNew.length - i),
          centerPosition.x + seriesNew[i].radius,
          centerPosition.y - eachSpacing * (seriesNew.length - i - 1)
        ]
        context.beginPath()
        context.setLineWidth(funnelOption.borderWidth * opts.pix)
        context.setStrokeStyle(funnelOption.borderColor)
        var fillColor = hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
        if (funnelOption.linearType == 'custom') {
          var grd = context.createLinearGradient(
            seriesNew[i].radius,
            -eachSpacing,
            -seriesNew[i].radius,
            -eachSpacing
          )
          grd.addColorStop(0, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          grd.addColorStop(
            0.5,
            hexToRgb(funnelOption.customColor[seriesNew[i].linearIndex], funnelOption.fillOpacity)
          )
          grd.addColorStop(1, hexToRgb(seriesNew[i].color, funnelOption.fillOpacity))
          fillColor = grd
        }
        context.setFillStyle(fillColor)
        context.moveTo(0, 0)
        context.lineTo(-seriesNew[i + 1].radius, 0)
        context.lineTo(-seriesNew[i].radius, -eachSpacing)
        context.lineTo(seriesNew[i].radius, -eachSpacing)
        context.lineTo(seriesNew[i + 1].radius, 0)
        context.lineTo(0, 0)
        context.closePath()
        context.fill()
        if (funnelOption.border == true) {
          context.stroke()
        }
      }
      context.translate(0, eachSpacing)
    }
  }

  context.restore()
  if (opts.dataLabel !== false && process === 1) {
    drawFunnelText(
      seriesNew,
      opts,
      context,
      eachSpacing,
      funnelOption.labelAlign,
      activeWidth,
      centerPosition
    )
  }
  if (process === 1) {
    drawFunnelCenterText(
      seriesNew,
      opts,
      context,
      eachSpacing,
      funnelOption.labelAlign,
      activeWidth,
      centerPosition
    )
  }
  return {
    center: centerPosition,
    radius: radius,
    series: seriesNew
  }
}

function drawFunnelText(
  series,
  opts,
  context,
  eachSpacing,
  labelAlign,
  activeWidth,
  centerPosition
) {
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    if (item.labelShow === false) {
      continue
    }
    let startX, endX, startY, fontSize
    let text = item.formatter
      ? item.formatter(item, i, series, opts)
      : util.toFixed(item._proportion_ * 100) + '%'
    text = item.labelText ? item.labelText : text
    if (labelAlign == 'right') {
      if (i == series.length - 1) {
        startX = (item.funnelArea[2] + centerPosition.x) / 2
      } else {
        startX = (item.funnelArea[2] + series[i + 1].funnelArea[2]) / 2
      }
      endX = startX + activeWidth * 2
      startY = item.funnelArea[1] + eachSpacing / 2
      fontSize = item.textSize * opts.pix || opts.fontSize * opts.pix
      context.setLineWidth(1 * opts.pix)
      context.setStrokeStyle(item.color)
      context.setFillStyle(item.color)
      context.beginPath()
      context.moveTo(startX, startY)
      context.lineTo(endX, startY)
      context.stroke()
      context.closePath()
      context.beginPath()
      context.moveTo(endX, startY)
      context.arc(endX, startY, 2 * opts.pix, 0, 2 * Math.PI)
      context.closePath()
      context.fill()
      context.beginPath()
      context.setFontSize(fontSize)
      context.setFillStyle(item.textColor || opts.fontColor)
      context.fillText(text, endX + 5, startY + fontSize / 2 - 2)
      context.closePath()
      context.stroke()
      context.closePath()
    }
    if (labelAlign == 'left') {
      if (i == series.length - 1) {
        startX = (item.funnelArea[0] + centerPosition.x) / 2
      } else {
        startX = (item.funnelArea[0] + series[i + 1].funnelArea[0]) / 2
      }
      endX = startX - activeWidth * 2
      startY = item.funnelArea[1] + eachSpacing / 2
      fontSize = item.textSize * opts.pix || opts.fontSize * opts.pix
      context.setLineWidth(1 * opts.pix)
      context.setStrokeStyle(item.color)
      context.setFillStyle(item.color)
      context.beginPath()
      context.moveTo(startX, startY)
      context.lineTo(endX, startY)
      context.stroke()
      context.closePath()
      context.beginPath()
      context.moveTo(endX, startY)
      context.arc(endX, startY, 2, 0, 2 * Math.PI)
      context.closePath()
      context.fill()
      context.beginPath()
      context.setFontSize(fontSize)
      context.setFillStyle(item.textColor || opts.fontColor)
      context.fillText(
        text,
        endX - 5 - measureText(text, fontSize, context),
        startY + fontSize / 2 - 2
      )
      context.closePath()
      context.stroke()
      context.closePath()
    }
  }
}

function drawFunnelCenterText(
  series,
  opts,
  context,
  eachSpacing,
  labelAlign,
  activeWidth,
  centerPosition
) {
  for (let i = 0; i < series.length; i++) {
    let item = series[i]
    let startY, fontSize
    if (item.centerText) {
      startY = item.funnelArea[1] + eachSpacing / 2
      fontSize = item.centerTextSize * opts.pix || opts.fontSize * opts.pix
      context.beginPath()
      context.setFontSize(fontSize)
      context.setFillStyle(item.centerTextColor || '#FFFFFF')
      context.fillText(
        item.centerText,
        centerPosition.x - measureText(item.centerText, fontSize, context) / 2,
        startY + fontSize / 2 - 2
      )
      context.closePath()
      context.stroke()
      context.closePath()
    }
  }
}

function drawCanvas(opts, context) {
  context.save()
  context.translate(0, 0.5)
  context.restore()
  context.draw()
}

var Timing = {
  easeIn: function easeIn(pos) {
    return Math.pow(pos, 3)
  },
  easeOut: function easeOut(pos) {
    return Math.pow(pos - 1, 3) + 1
  },
  easeInOut: function easeInOut(pos) {
    if ((pos /= 0.5) < 1) {
      return 0.5 * Math.pow(pos, 3)
    } else {
      return 0.5 * (Math.pow(pos - 2, 3) + 2)
    }
  },
  linear: function linear(pos) {
    return pos
  }
}

function Animation(opts) {
  this.isStop = false
  opts.duration = typeof opts.duration === 'undefined' ? 1000 : opts.duration
  opts.timing = opts.timing || 'easeInOut'
  var delay = 17
  function createAnimationFrame() {
    if (typeof setTimeout !== 'undefined') {
      return function (step, delay) {
        setTimeout(function () {
          var timeStamp = +new Date()
          step(timeStamp)
        }, delay)
      }
    } else if (typeof requestAnimationFrame !== 'undefined') {
      return requestAnimationFrame
    } else {
      return function (step) {
        step(null)
      }
    }
  }
  var animationFrame = createAnimationFrame()
  var startTimeStamp = null
  var _step = function step(timestamp) {
    if (timestamp === null || this.isStop === true) {
      opts.onProcess && opts.onProcess(1)
      opts.onAnimationFinish && opts.onAnimationFinish()
      return
    }
    if (startTimeStamp === null) {
      startTimeStamp = timestamp
    }
    if (timestamp - startTimeStamp < opts.duration) {
      var process = (timestamp - startTimeStamp) / opts.duration
      var timingFunction = Timing[opts.timing]
      process = timingFunction(process)
      opts.onProcess && opts.onProcess(process)
      animationFrame(_step, delay)
    } else {
      opts.onProcess && opts.onProcess(1)
      opts.onAnimationFinish && opts.onAnimationFinish()
    }
  }
  _step = _step.bind(this)
  animationFrame(_step, delay)
}

Animation.prototype.stop = function () {
  this.isStop = true
}

function drawCharts(type, opts, config, context) {
  var _this = this
  var series = opts.series
  //兼容ECharts饼图类数据格式
  if (
    type === 'pie' ||
    type === 'ring' ||
    type === 'mount' ||
    type === 'rose' ||
    type === 'funnel'
  ) {
    series = fixPieSeries(series, opts, config)
  }
  var categories = opts.categories
  if (type === 'mount') {
    categories = []
    for (let j = 0; j < series.length; j++) {
      if (series[j].show !== false) categories.push(series[j].name)
    }
    opts.categories = categories
  }
  series = fillSeries(series, opts, config)
  var duration = opts.animation ? opts.duration : 0
  _this.animationInstance && _this.animationInstance.stop()
  var seriesMA = null
  if (type == 'candle') {
    let average = assign({}, opts.extra.candle.average)
    if (average.show) {
      seriesMA = calCandleMA(average.day, average.name, average.color, series[0].data)
      seriesMA = fillSeries(seriesMA, opts, config)
      opts.seriesMA = seriesMA
    } else if (opts.seriesMA) {
      seriesMA = opts.seriesMA = fillSeries(opts.seriesMA, opts, config)
    } else {
      seriesMA = series
    }
  } else {
    seriesMA = series
  }
  /* 过滤掉show=false的series */
  opts._series_ = series = filterSeries(series)
  //重新计算图表区域
  opts.area = new Array(4)
  //复位绘图区域
  for (let j = 0; j < 4; j++) {
    opts.area[j] = opts.padding[j] * opts.pix
  }
  //通过计算三大区域：图例、X轴、Y轴的大小，确定绘图区域
  var _calLegendData = calLegendData(seriesMA, opts, config, opts.chartData, context),
    legendHeight = _calLegendData.area.wholeHeight,
    legendWidth = _calLegendData.area.wholeWidth

  switch (opts.legend.position) {
    case 'top':
      opts.area[0] += legendHeight
      break
    case 'bottom':
      opts.area[2] += legendHeight
      break
    case 'left':
      opts.area[3] += legendWidth
      break
    case 'right':
      opts.area[1] += legendWidth
      break
  }

  let _calYAxisData = {},
    yAxisWidth = 0
  if (
    opts.type === 'line' ||
    opts.type === 'column' ||
    opts.type === 'mount' ||
    opts.type === 'area' ||
    opts.type === 'mix' ||
    opts.type === 'candle' ||
    opts.type === 'scatter' ||
    opts.type === 'bubble' ||
    opts.type === 'bar'
  ) {
    _calYAxisData = calYAxisData(series, opts, config, context)
    yAxisWidth = _calYAxisData.yAxisWidth
    //如果显示Y轴标题
    if (opts.yAxis.showTitle) {
      let maxTitleHeight = 0
      for (let i = 0; i < opts.yAxis.data.length; i++) {
        maxTitleHeight = Math.max(
          maxTitleHeight,
          opts.yAxis.data[i].titleFontSize
            ? opts.yAxis.data[i].titleFontSize * opts.pix
            : config.fontSize
        )
      }
      opts.area[0] += maxTitleHeight
    }
    let rightIndex = 0,
      leftIndex = 0
    //计算主绘图区域左右位置
    for (let i = 0; i < yAxisWidth.length; i++) {
      if (yAxisWidth[i].position == 'left') {
        if (leftIndex > 0) {
          opts.area[3] += yAxisWidth[i].width + opts.yAxis.padding * opts.pix
        } else {
          opts.area[3] += yAxisWidth[i].width
        }
        leftIndex += 1
      } else if (yAxisWidth[i].position == 'right') {
        if (rightIndex > 0) {
          opts.area[1] += yAxisWidth[i].width + opts.yAxis.padding * opts.pix
        } else {
          opts.area[1] += yAxisWidth[i].width
        }
        rightIndex += 1
      }
    }
  } else {
    config.yAxisWidth = yAxisWidth
  }
  opts.chartData.yAxisData = _calYAxisData

  if (
    opts.categories &&
    opts.categories.length &&
    opts.type !== 'radar' &&
    opts.type !== 'gauge' &&
    opts.type !== 'bar'
  ) {
    opts.chartData.xAxisData = getXAxisPoints(opts.categories, opts, config)
    let _calCategoriesData = calCategoriesData(
        opts.categories,
        opts,
        config,
        opts.chartData.xAxisData.eachSpacing,
        context
      ),
      xAxisHeight = _calCategoriesData.xAxisHeight,
      angle = _calCategoriesData.angle
    config.xAxisHeight = xAxisHeight
    config._xAxisTextAngle_ = angle
    opts.area[2] += xAxisHeight
    opts.chartData.categoriesData = _calCategoriesData
  } else {
    if (
      opts.type === 'line' ||
      opts.type === 'area' ||
      opts.type === 'scatter' ||
      opts.type === 'bubble' ||
      opts.type === 'bar'
    ) {
      opts.chartData.xAxisData = calXAxisData(series, opts, config, context)
      categories = opts.chartData.xAxisData.rangesFormat
      let _calCategoriesData = calCategoriesData(
          categories,
          opts,
          config,
          opts.chartData.xAxisData.eachSpacing,
          context
        ),
        xAxisHeight = _calCategoriesData.xAxisHeight,
        angle = _calCategoriesData.angle
      config.xAxisHeight = xAxisHeight
      config._xAxisTextAngle_ = angle
      opts.area[2] += xAxisHeight
      opts.chartData.categoriesData = _calCategoriesData
    } else {
      opts.chartData.xAxisData = {
        xAxisPoints: []
      }
    }
  }

  //计算右对齐偏移距离
  if (
    opts.enableScroll &&
    opts.xAxis.scrollAlign == 'right' &&
    opts._scrollDistance_ === undefined
  ) {
    let offsetLeft = 0,
      xAxisPoints = opts.chartData.xAxisData.xAxisPoints,
      startX = opts.chartData.xAxisData.startX,
      endX = opts.chartData.xAxisData.endX,
      eachSpacing = opts.chartData.xAxisData.eachSpacing
    let totalWidth = eachSpacing * (xAxisPoints.length - 1)
    let screenWidth = endX - startX
    offsetLeft = screenWidth - totalWidth
    _this.scrollOption.currentOffset = offsetLeft
    _this.scrollOption.startTouchX = offsetLeft
    _this.scrollOption.distance = 0
    _this.scrollOption.lastMoveTime = 0
    opts._scrollDistance_ = offsetLeft
  }

  if (type === 'pie' || type === 'ring' || type === 'rose') {
    config._pieTextMaxLength_ =
      opts.dataLabel === false ? 0 : getPieTextMaxLength(seriesMA, config, context, opts)
  }

  switch (type) {
    case 'word':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function (process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawWordCloudDataPoints(series, opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'map':
      context.clearRect(0, 0, opts.width, opts.height)
      drawMapDataPoints(series, opts, config, context)
      setTimeout(() => {
        this.uevent.trigger('renderComplete')
      }, 50)
      break
    case 'funnel':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function (process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.funnelData = drawFunnelDataPoints(series, opts, config, context, process)
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'line':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawLineDataPoints = drawLineDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawLineDataPoints.xAxisPoints,
            calPoints = _drawLineDataPoints.calPoints,
            eachSpacing = _drawLineDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'scatter':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawScatterDataPoints = drawScatterDataPoints(
              series,
              opts,
              config,
              context,
              process
            ),
            xAxisPoints = _drawScatterDataPoints.xAxisPoints,
            calPoints = _drawScatterDataPoints.calPoints,
            eachSpacing = _drawScatterDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'bubble':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawBubbleDataPoints = drawBubbleDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawBubbleDataPoints.xAxisPoints,
            calPoints = _drawBubbleDataPoints.calPoints,
            eachSpacing = _drawBubbleDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'mix':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawMixDataPoints = drawMixDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawMixDataPoints.xAxisPoints,
            calPoints = _drawMixDataPoints.calPoints,
            eachSpacing = _drawMixDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'column':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawColumnDataPoints = drawColumnDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawColumnDataPoints.xAxisPoints,
            calPoints = _drawColumnDataPoints.calPoints,
            eachSpacing = _drawColumnDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'mount':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawMountDataPoints = drawMountDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawMountDataPoints.xAxisPoints,
            calPoints = _drawMountDataPoints.calPoints,
            eachSpacing = _drawMountDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'bar':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawXAxis(categories, opts, config, context)
          var _drawBarDataPoints = drawBarDataPoints(series, opts, config, context, process),
            yAxisPoints = _drawBarDataPoints.yAxisPoints,
            calPoints = _drawBarDataPoints.calPoints,
            eachSpacing = _drawBarDataPoints.eachSpacing
          opts.chartData.yAxisPoints = yAxisPoints
          opts.chartData.xAxisPoints = opts.chartData.xAxisData.xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, yAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'area':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawAreaDataPoints = drawAreaDataPoints(series, opts, config, context, process),
            xAxisPoints = _drawAreaDataPoints.xAxisPoints,
            calPoints = _drawAreaDataPoints.calPoints,
            eachSpacing = _drawAreaDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'ring':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.pieData = drawPieDataPoints(series, opts, config, context, process)
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'pie':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.pieData = drawPieDataPoints(series, opts, config, context, process)
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'rose':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.pieData = drawRoseDataPoints(series, opts, config, context, process)
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'radar':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.radarData = drawRadarDataPoints(series, opts, config, context, process)
          drawLegend(opts.series, opts, config, context, opts.chartData)
          drawToolTipBridge(opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'arcbar':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.arcbarData = drawArcbarDataPoints(series, opts, config, context, process)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'gauge':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          opts.chartData.gaugeData = drawGaugeDataPoints(
            categories,
            series,
            opts,
            config,
            context,
            process
          )
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
    case 'candle':
      this.animationInstance = new Animation({
        timing: opts.timing,
        duration: duration,
        onProcess: function onProcess(process) {
          context.clearRect(0, 0, opts.width, opts.height)
          if (opts.rotate) {
            contextRotate(context, opts)
          }
          drawYAxisGrid(categories, opts, config, context)
          drawXAxis(categories, opts, config, context)
          var _drawCandleDataPoints = drawCandleDataPoints(
              series,
              seriesMA,
              opts,
              config,
              context,
              process
            ),
            xAxisPoints = _drawCandleDataPoints.xAxisPoints,
            calPoints = _drawCandleDataPoints.calPoints,
            eachSpacing = _drawCandleDataPoints.eachSpacing
          opts.chartData.xAxisPoints = xAxisPoints
          opts.chartData.calPoints = calPoints
          opts.chartData.eachSpacing = eachSpacing
          drawYAxis(series, opts, config, context)
          if (opts.enableMarkLine !== false && process === 1) {
            drawMarkLine(opts, config, context)
          }
          if (seriesMA) {
            drawLegend(seriesMA, opts, config, context, opts.chartData)
          } else {
            drawLegend(opts.series, opts, config, context, opts.chartData)
          }
          drawToolTipBridge(opts, config, context, process, eachSpacing, xAxisPoints)
          drawCanvas(opts, context)
        },
        onAnimationFinish: function onAnimationFinish() {
          _this.uevent.trigger('renderComplete')
        }
      })
      break
  }
}

function uChartsEvent() {
  this.events = {}
}

uChartsEvent.prototype.addEventListener = function (type, listener) {
  this.events[type] = this.events[type] || []
  this.events[type].push(listener)
}

uChartsEvent.prototype.delEventListener = function (type) {
  this.events[type] = []
}

uChartsEvent.prototype.trigger = function () {
  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key]
  }
  var type = args[0]
  var params = args.slice(1)
  if (!!this.events[type]) {
    this.events[type].forEach(function (listener) {
      try {
        listener.apply(null, params)
      } catch (e) {
        //console.log('[uCharts] '+e);
      }
    })
  }
}

var uCharts = function uCharts(opts) {
  opts.pix = opts.pixelRatio ? opts.pixelRatio : 1
  opts.fontSize = opts.fontSize ? opts.fontSize : 13
  opts.fontColor = opts.fontColor ? opts.fontColor : config.fontColor
  if (opts.background == '' || opts.background == 'none') {
    opts.background = '#FFFFFF'
  }
  opts.title = assign({}, opts.title)
  opts.subtitle = assign({}, opts.subtitle)
  opts.duration = opts.duration ? opts.duration : 1000
  opts.yAxis = assign(
    {},
    {
      data: [],
      showTitle: false,
      disabled: false,
      disableGrid: false,
      gridSet: 'number',
      splitNumber: 5,
      gridType: 'solid',
      dashLength: 4 * opts.pix,
      gridColor: '#cccccc',
      padding: 10,
      fontColor: '#666666'
    },
    opts.yAxis
  )
  opts.xAxis = assign(
    {},
    {
      rotateLabel: false,
      rotateAngle: 45,
      disabled: false,
      disableGrid: false,
      splitNumber: 5,
      calibration: false,
      fontColor: '#666666',
      fontSize: 13,
      lineHeight: 20,
      marginTop: 0,
      gridType: 'solid',
      dashLength: 4,
      scrollAlign: 'left',
      boundaryGap: 'center',
      axisLine: true,
      axisLineColor: '#cccccc',
      titleFontSize: 13,
      titleOffsetY: 0,
      titleOffsetX: 0,
      titleFontColor: '#666666'
    },
    opts.xAxis
  )
  opts.xAxis.scrollPosition = opts.xAxis.scrollAlign
  opts.legend = assign(
    {},
    {
      show: true,
      position: 'bottom',
      float: 'center',
      backgroundColor: 'rgba(0,0,0,0)',
      borderColor: 'rgba(0,0,0,0)',
      borderWidth: 0,
      padding: 5,
      margin: 5,
      itemGap: 10,
      fontSize: opts.fontSize,
      lineHeight: opts.fontSize,
      fontColor: opts.fontColor,
      formatter: {},
      hiddenColor: '#CECECE'
    },
    opts.legend
  )
  opts.extra = assign(
    {
      tooltip: {
        legendShape: 'auto'
      }
    },
    opts.extra
  )
  opts.rotate = opts.rotate ? true : false
  opts.animation = opts.animation ? true : false
  opts.rotate = opts.rotate ? true : false
  opts.canvas2d = opts.canvas2d ? true : false

  let config$$1 = assign({}, config)
  config$$1.color = opts.color ? opts.color : config$$1.color
  if (opts.type == 'pie') {
    config$$1.pieChartLinePadding =
      opts.dataLabel === false
        ? 0
        : opts.extra.pie.labelWidth * opts.pix || config$$1.pieChartLinePadding * opts.pix
  }
  if (opts.type == 'ring') {
    config$$1.pieChartLinePadding =
      opts.dataLabel === false
        ? 0
        : opts.extra.ring.labelWidth * opts.pix || config$$1.pieChartLinePadding * opts.pix
  }
  if (opts.type == 'rose') {
    config$$1.pieChartLinePadding =
      opts.dataLabel === false
        ? 0
        : opts.extra.rose.labelWidth * opts.pix || config$$1.pieChartLinePadding * opts.pix
  }
  config$$1.pieChartTextPadding =
    opts.dataLabel === false ? 0 : config$$1.pieChartTextPadding * opts.pix

  //屏幕旋转
  config$$1.rotate = opts.rotate
  if (opts.rotate) {
    let tempWidth = opts.width
    let tempHeight = opts.height
    opts.width = tempHeight
    opts.height = tempWidth
  }

  //适配高分屏
  opts.padding = opts.padding ? opts.padding : config$$1.padding
  config$$1.yAxisWidth = config.yAxisWidth * opts.pix
  config$$1.fontSize = opts.fontSize * opts.pix
  config$$1.titleFontSize = config.titleFontSize * opts.pix
  config$$1.subtitleFontSize = config.subtitleFontSize * opts.pix
  if (!opts.context) {
    throw new Error(
      '[uCharts] 未获取到context！注意：v2.0版本后，需要自行获取canvas的绘图上下文并传入opts.context！'
    )
  }
  this.context = opts.context
  if (!this.context.setTextAlign) {
    this.context.setStrokeStyle = function (e) {
      return (this.strokeStyle = e)
    }
    this.context.setLineWidth = function (e) {
      return (this.lineWidth = e)
    }
    this.context.setLineCap = function (e) {
      return (this.lineCap = e)
    }
    this.context.setFontSize = function (e) {
      return (this.font = e + 'px sans-serif')
    }
    this.context.setFillStyle = function (e) {
      return (this.fillStyle = e)
    }
    this.context.setTextAlign = function (e) {
      return (this.textAlign = e)
    }
    this.context.setTextBaseline = function (e) {
      return (this.textBaseline = e)
    }
    this.context.setShadow = function (offsetX, offsetY, blur, color) {
      this.shadowColor = color
      this.shadowOffsetX = offsetX
      this.shadowOffsetY = offsetY
      this.shadowBlur = blur
    }
    this.context.draw = function () {}
  }
  //兼容NVUEsetLineDash
  if (!this.context.setLineDash) {
    this.context.setLineDash = function (e) {}
  }
  opts.chartData = {}
  this.uevent = new uChartsEvent()
  this.scrollOption = {
    currentOffset: 0,
    startTouchX: 0,
    distance: 0,
    lastMoveTime: 0
  }
  this.opts = opts
  this.config = config$$1
  drawCharts.call(this, opts.type, opts, config$$1, this.context)
}

uCharts.prototype.updateData = function () {
  let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
  this.opts = assign({}, this.opts, data)
  this.opts.updateData = true
  let scrollPosition = data.scrollPosition || 'current'
  switch (scrollPosition) {
    case 'current':
      this.opts._scrollDistance_ = this.scrollOption.currentOffset
      break
    case 'left':
      this.opts._scrollDistance_ = 0
      this.scrollOption = {
        currentOffset: 0,
        startTouchX: 0,
        distance: 0,
        lastMoveTime: 0
      }
      break
    case 'right':
      let _calYAxisData = calYAxisData(this.opts.series, this.opts, this.config, this.context),
        yAxisWidth = _calYAxisData.yAxisWidth
      this.config.yAxisWidth = yAxisWidth
      let offsetLeft = 0
      let _getXAxisPoints0 = getXAxisPoints(this.opts.categories, this.opts, this.config),
        xAxisPoints = _getXAxisPoints0.xAxisPoints,
        startX = _getXAxisPoints0.startX,
        endX = _getXAxisPoints0.endX,
        eachSpacing = _getXAxisPoints0.eachSpacing
      let totalWidth = eachSpacing * (xAxisPoints.length - 1)
      let screenWidth = endX - startX
      offsetLeft = screenWidth - totalWidth
      this.scrollOption = {
        currentOffset: offsetLeft,
        startTouchX: offsetLeft,
        distance: 0,
        lastMoveTime: 0
      }
      this.opts._scrollDistance_ = offsetLeft
      break
  }
  drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.zoom = function () {
  var val =
    arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.opts.xAxis.itemCount
  if (this.opts.enableScroll !== true) {
    console.log('[uCharts] 请启用滚动条后使用')
    return
  }
  //当前屏幕中间点
  let centerPoint =
    Math.round(Math.abs(this.scrollOption.currentOffset) / this.opts.chartData.eachSpacing) +
    Math.round(this.opts.xAxis.itemCount / 2)
  this.opts.animation = false
  this.opts.xAxis.itemCount = val.itemCount
  //重新计算x轴偏移距离
  let _calYAxisData = calYAxisData(this.opts.series, this.opts, this.config, this.context),
    yAxisWidth = _calYAxisData.yAxisWidth
  this.config.yAxisWidth = yAxisWidth
  let offsetLeft = 0
  let _getXAxisPoints0 = getXAxisPoints(this.opts.categories, this.opts, this.config),
    xAxisPoints = _getXAxisPoints0.xAxisPoints,
    startX = _getXAxisPoints0.startX,
    endX = _getXAxisPoints0.endX,
    eachSpacing = _getXAxisPoints0.eachSpacing
  let centerLeft = eachSpacing * centerPoint
  let screenWidth = endX - startX
  let MaxLeft = screenWidth - eachSpacing * (xAxisPoints.length - 1)
  offsetLeft = screenWidth / 2 - centerLeft
  if (offsetLeft > 0) {
    offsetLeft = 0
  }
  if (offsetLeft < MaxLeft) {
    offsetLeft = MaxLeft
  }
  this.scrollOption = {
    currentOffset: offsetLeft,
    startTouchX: 0,
    distance: 0,
    lastMoveTime: 0
  }
  calValidDistance(this, offsetLeft, this.opts.chartData, this.config, this.opts)
  this.opts._scrollDistance_ = offsetLeft
  drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.dobuleZoom = function (e) {
  if (this.opts.enableScroll !== true) {
    console.log('[uCharts] 请启用滚动条后使用')
    return
  }
  const tcs = e.changedTouches
  if (tcs.length < 2) {
    return
  }
  for (var i = 0; i < tcs.length; i++) {
    tcs[i].x = tcs[i].x ? tcs[i].x : tcs[i].clientX
    tcs[i].y = tcs[i].y ? tcs[i].y : tcs[i].clientY
  }
  const ntcs = [getTouches(tcs[0], this.opts, e), getTouches(tcs[1], this.opts, e)]
  const xlength = Math.abs(ntcs[0].x - ntcs[1].x)
  // 记录初始的两指之间的数据
  if (!this.scrollOption.moveCount) {
    let cts0 = { changedTouches: [{ x: tcs[0].x, y: this.opts.area[0] / this.opts.pix + 2 }] }
    let cts1 = { changedTouches: [{ x: tcs[1].x, y: this.opts.area[0] / this.opts.pix + 2 }] }
    if (this.opts.rotate) {
      cts0 = {
        changedTouches: [
          {
            x: this.opts.height / this.opts.pix - this.opts.area[0] / this.opts.pix - 2,
            y: tcs[0].y
          }
        ]
      }
      cts1 = {
        changedTouches: [
          {
            x: this.opts.height / this.opts.pix - this.opts.area[0] / this.opts.pix - 2,
            y: tcs[1].y
          }
        ]
      }
    }
    const moveCurrent1 = this.getCurrentDataIndex(cts0).index
    const moveCurrent2 = this.getCurrentDataIndex(cts1).index
    const moveCount = Math.abs(moveCurrent1 - moveCurrent2)
    this.scrollOption.moveCount = moveCount
    this.scrollOption.moveCurrent1 = Math.min(moveCurrent1, moveCurrent2)
    this.scrollOption.moveCurrent2 = Math.max(moveCurrent1, moveCurrent2)
    return
  }

  let currentEachSpacing = xlength / this.scrollOption.moveCount
  let itemCount = (this.opts.width - this.opts.area[1] - this.opts.area[3]) / currentEachSpacing
  itemCount = itemCount <= 2 ? 2 : itemCount
  itemCount = itemCount >= this.opts.categories.length ? this.opts.categories.length : itemCount
  this.opts.animation = false
  this.opts.xAxis.itemCount = itemCount
  // 重新计算滚动条偏移距离
  let offsetLeft = 0
  let _getXAxisPoints0 = getXAxisPoints(this.opts.categories, this.opts, this.config),
    xAxisPoints = _getXAxisPoints0.xAxisPoints,
    startX = _getXAxisPoints0.startX,
    endX = _getXAxisPoints0.endX,
    eachSpacing = _getXAxisPoints0.eachSpacing
  let currentLeft = eachSpacing * this.scrollOption.moveCurrent1
  let screenWidth = endX - startX
  let MaxLeft = screenWidth - eachSpacing * (xAxisPoints.length - 1)
  offsetLeft = -currentLeft + Math.min(ntcs[0].x, ntcs[1].x) - this.opts.area[3] - eachSpacing
  if (offsetLeft > 0) {
    offsetLeft = 0
  }
  if (offsetLeft < MaxLeft) {
    offsetLeft = MaxLeft
  }
  this.scrollOption.currentOffset = offsetLeft
  this.scrollOption.startTouchX = 0
  this.scrollOption.distance = 0
  calValidDistance(this, offsetLeft, this.opts.chartData, this.config, this.opts)
  this.opts._scrollDistance_ = offsetLeft
  drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.stopAnimation = function () {
  this.animationInstance && this.animationInstance.stop()
}

uCharts.prototype.addEventListener = function (type, listener) {
  this.uevent.addEventListener(type, listener)
}

uCharts.prototype.delEventListener = function (type) {
  this.uevent.delEventListener(type)
}

uCharts.prototype.getCurrentDataIndex = function (e) {
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  if (touches) {
    let _touches$ = getTouches(touches, this.opts, e)
    if (this.opts.type === 'pie' || this.opts.type === 'ring') {
      return findPieChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.pieData,
        this.opts
      )
    } else if (this.opts.type === 'rose') {
      return findRoseChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.pieData,
        this.opts
      )
    } else if (this.opts.type === 'radar') {
      return findRadarChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.radarData,
        this.opts.categories.length
      )
    } else if (this.opts.type === 'funnel') {
      return findFunnelChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.funnelData
      )
    } else if (this.opts.type === 'map') {
      return findMapChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts
      )
    } else if (this.opts.type === 'word') {
      return findWordChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.wordCloudData
      )
    } else if (this.opts.type === 'bar') {
      return findBarChartCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.calPoints,
        this.opts,
        this.config,
        Math.abs(this.scrollOption.currentOffset)
      )
    } else {
      return findCurrentIndex(
        {
          x: _touches$.x,
          y: _touches$.y
        },
        this.opts.chartData.calPoints,
        this.opts,
        this.config,
        Math.abs(this.scrollOption.currentOffset)
      )
    }
  }
  return -1
}

uCharts.prototype.getLegendDataIndex = function (e) {
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  if (touches) {
    let _touches$ = getTouches(touches, this.opts, e)
    return findLegendIndex(
      {
        x: _touches$.x,
        y: _touches$.y
      },
      this.opts.chartData.legendData
    )
  }
  return -1
}

uCharts.prototype.touchLegend = function (e) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  if (touches) {
    var _touches$ = getTouches(touches, this.opts, e)
    var index = this.getLegendDataIndex(e)
    if (index >= 0) {
      if (this.opts.type == 'candle') {
        this.opts.seriesMA[index].show = !this.opts.seriesMA[index].show
      } else {
        this.opts.series[index].show = !this.opts.series[index].show
      }
      this.opts.animation = option.animation ? true : false
      this.opts._scrollDistance_ = this.scrollOption.currentOffset
      drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
    }
  }
}

uCharts.prototype.showToolTip = function (e) {
  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  if (!touches) {
    console.log('[uCharts] 未获取到event坐标信息')
  }
  var _touches$ = getTouches(touches, this.opts, e)
  var currentOffset = this.scrollOption.currentOffset
  var opts = assign({}, this.opts, {
    _scrollDistance_: currentOffset,
    animation: false
  })
  if (
    this.opts.type === 'line' ||
    this.opts.type === 'area' ||
    this.opts.type === 'column' ||
    this.opts.type === 'scatter' ||
    this.opts.type === 'bubble'
  ) {
    var current = this.getCurrentDataIndex(e)
    var index = option.index == undefined ? current.index : option.index
    if (index > -1 || index.length > 0) {
      var seriesData = getSeriesDataItem(this.opts.series, index, current.group)
      if (seriesData.length !== 0) {
        var _getToolTipData = getToolTipData(
            seriesData,
            this.opts,
            index,
            current.group,
            this.opts.categories,
            option
          ),
          textList = _getToolTipData.textList,
          offset = _getToolTipData.offset
        offset.y = _touches$.y
        opts.tooltip = {
          textList: option.textList !== undefined ? option.textList : textList,
          offset: option.offset !== undefined ? option.offset : offset,
          option: option,
          index: index,
          group: current.group
        }
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'mount') {
    var index = option.index == undefined ? this.getCurrentDataIndex(e).index : option.index
    if (index > -1) {
      var opts = assign({}, this.opts, { animation: false })
      var seriesData = assign({}, opts._series_[index])
      var textList = [
        {
          text: option.formatter
            ? option.formatter(seriesData, undefined, index, opts)
            : seriesData.name + ': ' + seriesData.data,
          color: seriesData.color,
          legendShape:
            this.opts.extra.tooltip.legendShape == 'auto'
              ? seriesData.legendShape
              : this.opts.extra.tooltip.legendShape
        }
      ]
      var offset = {
        x: opts.chartData.calPoints[index].x,
        y: _touches$.y
      }
      opts.tooltip = {
        textList: option.textList ? option.textList : textList,
        offset: option.offset !== undefined ? option.offset : offset,
        option: option,
        index: index
      }
    }

    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'bar') {
    var current = this.getCurrentDataIndex(e)
    var index = option.index == undefined ? current.index : option.index
    if (index > -1 || index.length > 0) {
      var seriesData = getSeriesDataItem(this.opts.series, index, current.group)
      if (seriesData.length !== 0) {
        var _getToolTipData = getToolTipData(
            seriesData,
            this.opts,
            index,
            current.group,
            this.opts.categories,
            option
          ),
          textList = _getToolTipData.textList,
          offset = _getToolTipData.offset
        offset.x = _touches$.x
        opts.tooltip = {
          textList: option.textList !== undefined ? option.textList : textList,
          offset: option.offset !== undefined ? option.offset : offset,
          option: option,
          index: index
        }
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'mix') {
    var current = this.getCurrentDataIndex(e)
    var index = option.index == undefined ? current.index : option.index
    if (index > -1) {
      var currentOffset = this.scrollOption.currentOffset
      var opts = assign({}, this.opts, {
        _scrollDistance_: currentOffset,
        animation: false
      })
      var seriesData = getSeriesDataItem(this.opts.series, index)
      if (seriesData.length !== 0) {
        var _getMixToolTipData = getMixToolTipData(
            seriesData,
            this.opts,
            index,
            this.opts.categories,
            option
          ),
          textList = _getMixToolTipData.textList,
          offset = _getMixToolTipData.offset
        offset.y = _touches$.y
        opts.tooltip = {
          textList: option.textList ? option.textList : textList,
          offset: option.offset !== undefined ? option.offset : offset,
          option: option,
          index: index
        }
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'candle') {
    var current = this.getCurrentDataIndex(e)
    var index = option.index == undefined ? current.index : option.index
    if (index > -1) {
      var currentOffset = this.scrollOption.currentOffset
      var opts = assign({}, this.opts, {
        _scrollDistance_: currentOffset,
        animation: false
      })
      var seriesData = getSeriesDataItem(this.opts.series, index)
      if (seriesData.length !== 0) {
        var _getToolTipData = getCandleToolTipData(
            this.opts.series[0].data,
            seriesData,
            this.opts,
            index,
            this.opts.categories,
            this.opts.extra.candle,
            option
          ),
          textList = _getToolTipData.textList,
          offset = _getToolTipData.offset
        offset.y = _touches$.y
        opts.tooltip = {
          textList: option.textList ? option.textList : textList,
          offset: option.offset !== undefined ? option.offset : offset,
          option: option,
          index: index
        }
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (
    this.opts.type === 'pie' ||
    this.opts.type === 'ring' ||
    this.opts.type === 'rose' ||
    this.opts.type === 'funnel'
  ) {
    var index = option.index == undefined ? this.getCurrentDataIndex(e) : option.index
    if (index > -1) {
      var opts = assign({}, this.opts, { animation: false })
      var seriesData = assign({}, opts._series_[index])
      var textList = [
        {
          text: option.formatter
            ? option.formatter(seriesData, undefined, index, opts)
            : seriesData.name + ': ' + seriesData.data,
          color: seriesData.color,
          legendShape:
            this.opts.extra.tooltip.legendShape == 'auto'
              ? seriesData.legendShape
              : this.opts.extra.tooltip.legendShape
        }
      ]
      var offset = {
        x: _touches$.x,
        y: _touches$.y
      }
      opts.tooltip = {
        textList: option.textList ? option.textList : textList,
        offset: option.offset !== undefined ? option.offset : offset,
        option: option,
        index: index
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'map') {
    var index = option.index == undefined ? this.getCurrentDataIndex(e) : option.index
    if (index > -1) {
      var opts = assign({}, this.opts, { animation: false })
      var seriesData = assign({}, this.opts.series[index])
      seriesData.name = seriesData.properties.name
      var textList = [
        {
          text: option.formatter
            ? option.formatter(seriesData, undefined, index, this.opts)
            : seriesData.name,
          color: seriesData.color,
          legendShape:
            this.opts.extra.tooltip.legendShape == 'auto'
              ? seriesData.legendShape
              : this.opts.extra.tooltip.legendShape
        }
      ]
      var offset = {
        x: _touches$.x,
        y: _touches$.y
      }
      opts.tooltip = {
        textList: option.textList ? option.textList : textList,
        offset: option.offset !== undefined ? option.offset : offset,
        option: option,
        index: index
      }
    }
    opts.updateData = false
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'word') {
    var index = option.index == undefined ? this.getCurrentDataIndex(e) : option.index
    if (index > -1) {
      var opts = assign({}, this.opts, { animation: false })
      var seriesData = assign({}, this.opts.series[index])
      var textList = [
        {
          text: option.formatter
            ? option.formatter(seriesData, undefined, index, this.opts)
            : seriesData.name,
          color: seriesData.color,
          legendShape:
            this.opts.extra.tooltip.legendShape == 'auto'
              ? seriesData.legendShape
              : this.opts.extra.tooltip.legendShape
        }
      ]
      var offset = {
        x: _touches$.x,
        y: _touches$.y
      }
      opts.tooltip = {
        textList: option.textList ? option.textList : textList,
        offset: option.offset !== undefined ? option.offset : offset,
        option: option,
        index: index
      }
    }
    opts.updateData = false
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
  if (this.opts.type === 'radar') {
    var index = option.index == undefined ? this.getCurrentDataIndex(e) : option.index
    if (index > -1) {
      var opts = assign({}, this.opts, { animation: false })
      var seriesData = getSeriesDataItem(this.opts.series, index)
      if (seriesData.length !== 0) {
        var textList = seriesData.map((item) => {
          return {
            text: option.formatter
              ? option.formatter(item, this.opts.categories[index], index, this.opts)
              : item.name + ': ' + item.data,
            color: item.color,
            legendShape:
              this.opts.extra.tooltip.legendShape == 'auto'
                ? item.legendShape
                : this.opts.extra.tooltip.legendShape
          }
        })
        var offset = {
          x: _touches$.x,
          y: _touches$.y
        }
        opts.tooltip = {
          textList: option.textList ? option.textList : textList,
          offset: option.offset !== undefined ? option.offset : offset,
          option: option,
          index: index
        }
      }
    }
    drawCharts.call(this, opts.type, opts, this.config, this.context)
  }
}

uCharts.prototype.translate = function (distance) {
  this.scrollOption = {
    currentOffset: distance,
    startTouchX: distance,
    distance: 0,
    lastMoveTime: 0
  }
  let opts = assign({}, this.opts, {
    _scrollDistance_: distance,
    animation: false
  })
  drawCharts.call(this, this.opts.type, opts, this.config, this.context)
}

uCharts.prototype.scrollStart = function (e) {
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  var _touches$ = getTouches(touches, this.opts, e)
  if (touches && this.opts.enableScroll === true) {
    this.scrollOption.startTouchX = _touches$.x
  }
}

uCharts.prototype.scroll = function (e) {
  if (this.scrollOption.lastMoveTime === 0) {
    this.scrollOption.lastMoveTime = Date.now()
  }
  let Limit = this.opts.touchMoveLimit || 60
  let currMoveTime = Date.now()
  let duration = currMoveTime - this.scrollOption.lastMoveTime
  if (duration < Math.floor(1000 / Limit)) return
  if (this.scrollOption.startTouchX == 0) return
  this.scrollOption.lastMoveTime = currMoveTime
  var touches = null
  if (e.changedTouches) {
    touches = e.changedTouches[0]
  } else {
    touches = e.mp.changedTouches[0]
  }
  if (touches && this.opts.enableScroll === true) {
    var _touches$ = getTouches(touches, this.opts, e)
    var _distance
    _distance = _touches$.x - this.scrollOption.startTouchX
    var currentOffset = this.scrollOption.currentOffset
    var validDistance = calValidDistance(
      this,
      currentOffset + _distance,
      this.opts.chartData,
      this.config,
      this.opts
    )
    this.scrollOption.distance = _distance = validDistance - currentOffset
    var opts = assign({}, this.opts, {
      _scrollDistance_: currentOffset + _distance,
      animation: false
    })
    this.opts = opts
    drawCharts.call(this, opts.type, opts, this.config, this.context)
    return currentOffset + _distance
  }
}

uCharts.prototype.scrollEnd = function (e) {
  if (this.opts.enableScroll === true) {
    var _scrollOption = this.scrollOption,
      currentOffset = _scrollOption.currentOffset,
      distance = _scrollOption.distance
    this.scrollOption.currentOffset = currentOffset + distance
    this.scrollOption.distance = 0
    this.scrollOption.moveCount = 0
  }
}

export default uCharts
